method-ray 0.1.3 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c950d346d7e01dfcf74b912ee1677450b9ea3d95c3baac937062cc8bf4363163
-  data.tar.gz: d9804ea668007c228bb12078ebaa3ec7e4c3b37daa372b2a801765b90978136a
+  metadata.gz: 1a219edf198245163ff36fbcc9e211dbfea2d5e5f41a467ee24636286967f4b9
+  data.tar.gz: 7a82426e9c5b0ba53a2d1ca8bab90da2a4b4eb58316af7cfb8a576dc6dc28b64
 SHA512:
-  metadata.gz: 1a572ea77523293d586c6acd284994206f1b4b678ede730f50fe619f98762f1c215daf5b8e899400f3872769078aa033bd6cea701515533acfe11d7695e0fd26
-  data.tar.gz: 2f20387f762e32766281f6813971b3f546f8cb6476482cbe13d3cfb1fe03e6761e2304be3a5eeade1cb8261d7e5197a1416e3f0cfad280450b54a16acdddacb1
+  metadata.gz: cac68a8608631ce81f145b17743ff7ec519e24f1ac2b92c90732d3f9fedd4badb26715fd5120b8a648fd574313383ac2dbd02d71cdfe98004ffafe5714e39cf3
+  data.tar.gz: ded1386c832dfc9784c360d3685ce3431437d7cae1c155e02dc6606e3e155789f9f2ad42d5e4285aed6c8cb1dbf8231ac8f81392bf25a0536e3fd18e882537f3

data/CHANGELOG.md

@@ -5,6 +5,21 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.1.4] - 2026-02-16
+
+### Added
+
+- Method return type inference for user-defined methods ([#18](https://github.com/dak2/method-ray/pull/18))
+- Parameter type propagation from call-site arguments to method parameters ([#19](https://github.com/dak2/method-ray/pull/19))
+- Receiver-less method call support (ImplicitSelfCall) ([#20](https://github.com/dak2/method-ray/pull/20))
+- `attr_reader`/`attr_writer`/`attr_accessor` support for type inference ([#21](https://github.com/dak2/method-ray/pull/21))
+- `if`/`unless`/`case` conditional type inference ([#22](https://github.com/dak2/method-ray/pull/22))
+- `ConstantReadNode`/`ConstantPathNode` support for type inference ([#23](https://github.com/dak2/method-ray/pull/23))
+
+### Changed
+
+- Split install.rs and integration tests into focused modules ([#17](https://github.com/dak2/method-ray/pull/17))
+
 ## [0.1.3] - 2025-02-08
 
 ### Added
@@ -54,6 +69,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Initial release
 - `methodray check` - Static type checking for Ruby files
 
+[0.1.4]: https://github.com/dak2/method-ray/releases/tag/v0.1.4
 [0.1.3]: https://github.com/dak2/method-ray/releases/tag/v0.1.3
 [0.1.2]: https://github.com/dak2/method-ray/releases/tag/v0.1.2
 [0.1.1]: https://github.com/dak2/method-ray/releases/tag/v0.1.1

data/ext/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "methodray"
-version = "0.1.3"
+version = "0.1.4"
 edition = "2021"
 
 [lib]

data/lib/methodray/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module MethodRay
-  VERSION = '0.1.3'
+  VERSION = '0.1.4'
 end

data/rust/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "methodray-core"
-version = "0.1.3"
+version = "0.1.4"
 edition = "2021"
 
 [lib]

data/rust/src/analyzer/attributes.rs

@@ -0,0 +1,57 @@
+//! Attribute accessor support - synthesize getter/setter methods for attr_reader/attr_writer/attr_accessor
+
+use crate::env::GlobalEnv;
+use crate::types::Type;
+
+use super::dispatch::AttrKind;
+
+/// Register synthesized getter/setter methods for attr_reader/attr_writer/attr_accessor.
+///
+/// - attr_reader :name → registers User#name (getter, return = @name vertex)
+/// - attr_writer :name → registers User#name= (setter, param → @name edge)
+/// - attr_accessor :name → registers both getter and setter
+///
+/// If @name has no VertexId yet, one is pre-allocated so that later assignments
+/// (e.g., `@name = "Alice"` in initialize) propagate into the same vertex.
+pub(crate) fn process_attr_declaration(
+    genv: &mut GlobalEnv,
+    kind: AttrKind,
+    attr_names: Vec<String>,
+) {
+    let Some(class_name) = genv.scope_manager.current_class_name() else {
+        return;
+    };
+    let recv_ty = Type::instance(&class_name);
+
+    for attr_name in attr_names {
+        let ivar_name = format!("@{}", attr_name);
+
+        // Get or pre-allocate VertexId for @name
+        let ivar_vtx = match genv.scope_manager.lookup_instance_var(&ivar_name) {
+            Some(vtx) => vtx,
+            None => {
+                let vtx = genv.new_vertex();
+                genv.scope_manager
+                    .set_instance_var_in_class(ivar_name, vtx);
+                vtx
+            }
+        };
+
+        // Register getter (attr_reader / attr_accessor)
+        if matches!(kind, AttrKind::Reader | AttrKind::Accessor) {
+            genv.register_user_method(recv_ty.clone(), &attr_name, ivar_vtx, vec![]);
+        }
+
+        // Register setter (attr_writer / attr_accessor)
+        if matches!(kind, AttrKind::Writer | AttrKind::Accessor) {
+            let param_vtx = genv.new_vertex();
+            genv.add_edge(param_vtx, ivar_vtx);
+            genv.register_user_method(
+                recv_ty.clone(),
+                &format!("{}=", attr_name),
+                ivar_vtx,
+                vec![param_vtx],
+            );
+        }
+    }
+}

data/rust/src/analyzer/blocks.rs

@@ -6,35 +6,121 @@
 //! - Managing block scope
 
 use crate::env::{GlobalEnv, LocalEnv, ScopeKind};
-use crate::graph::VertexId;
+use crate::graph::{ChangeSet, VertexId};
+
+use super::parameters::{install_optional_parameter, install_required_parameter, install_rest_parameter};
+
+/// Process block node
+pub(crate) fn process_block_node(
+    genv: &mut GlobalEnv,
+    lenv: &mut LocalEnv,
+    changes: &mut ChangeSet,
+    source: &str,
+    block_node: &ruby_prism::BlockNode,
+) -> Option<VertexId> {
+    process_block_node_with_params(genv, lenv, changes, source, block_node);
+    None
+}
+
+/// Process block node and return block parameter vertex IDs
+pub(crate) fn process_block_node_with_params(
+    genv: &mut GlobalEnv,
+    lenv: &mut LocalEnv,
+    changes: &mut ChangeSet,
+    source: &str,
+    block_node: &ruby_prism::BlockNode,
+) -> Vec<VertexId> {
+    enter_block_scope(genv);
+
+    let mut param_vtxs = Vec::new();
+
+    if let Some(params_node) = block_node.parameters() {
+        if let Some(block_params) = params_node.as_block_parameters_node() {
+            param_vtxs =
+                install_block_parameters_with_vtxs(genv, lenv, changes, source, &block_params);
+        }
+    }
+
+    if let Some(body) = block_node.body() {
+        if let Some(statements) = body.as_statements_node() {
+            super::install::install_statements(genv, lenv, changes, source, &statements);
+        } else {
+            super::install::install_node(genv, lenv, changes, source, &body);
+        }
+    }
+
+    exit_block_scope(genv);
 
-use super::parameters::install_required_parameter;
+    param_vtxs
+}
+
+/// Install block parameters and return their vertex IDs
+fn install_block_parameters_with_vtxs(
+    genv: &mut GlobalEnv,
+    lenv: &mut LocalEnv,
+    changes: &mut ChangeSet,
+    source: &str,
+    block_params: &ruby_prism::BlockParametersNode,
+) -> Vec<VertexId> {
+    let mut vtxs = Vec::new();
+
+    if let Some(params) = block_params.parameters() {
+        // Required parameters (most common in blocks)
+        for node in params.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_block_parameter(genv, lenv, name);
+                vtxs.push(vtx);
+            }
+        }
+
+        // Optional parameters: { |x = 1| ... }
+        for node in params.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();
+
+                if let Some(default_vtx) =
+                    super::install::install_node(genv, lenv, changes, source, &default_value)
+                {
+                    let vtx =
+                        install_optional_parameter(genv, lenv, changes, name, default_vtx);
+                    vtxs.push(vtx);
+                } else {
+                    let vtx = install_block_parameter(genv, lenv, name);
+                    vtxs.push(vtx);
+                }
+            }
+        }
+
+        // Rest parameter: { |*args| ... }
+        if let Some(rest_node) = params.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();
+                    let vtx = install_rest_parameter(genv, lenv, name);
+                    vtxs.push(vtx);
+                }
+            }
+        }
+    }
+
+    vtxs
+}
 
 /// Enter a new block scope
-///
-/// Creates a new scope for the block and enters it.
-/// Block scopes inherit variables from parent scopes.
-pub fn enter_block_scope(genv: &mut GlobalEnv) {
+fn enter_block_scope(genv: &mut GlobalEnv) {
     let block_scope_id = genv.scope_manager.new_scope(ScopeKind::Block);
     genv.scope_manager.enter_scope(block_scope_id);
 }
 
 /// Exit the current block scope
-pub fn exit_block_scope(genv: &mut GlobalEnv) {
+fn exit_block_scope(genv: &mut GlobalEnv) {
     genv.scope_manager.exit_scope();
 }
 
-/// Install block parameters as local variables
-///
-/// Block parameters are registered as Bot (untyped) type since we don't
-/// know what type will be passed from the iterator method.
-///
-/// # Example
-/// ```ruby
-/// [1, 2, 3].each { |x| x.to_s }  # 'x' is a block parameter
-/// ```
-pub fn install_block_parameter(genv: &mut GlobalEnv, lenv: &mut LocalEnv, name: String) -> VertexId {
-    // Reuse required parameter logic (Bot type)
+/// Install block parameter as a local variable (Bot type)
+fn install_block_parameter(genv: &mut GlobalEnv, lenv: &mut LocalEnv, name: String) -> VertexId {
     install_required_parameter(genv, lenv, name)
 }
 
@@ -51,12 +137,10 @@ mod tests {
         enter_block_scope(&mut genv);
         let block_scope_id = genv.scope_manager.current_scope().id;
 
-        // Should be in a new scope
         assert_ne!(initial_scope_id, block_scope_id);
 
         exit_block_scope(&mut genv);
 
-        // Should be back to initial scope
         assert_eq!(genv.scope_manager.current_scope().id, initial_scope_id);
     }
 
@@ -69,7 +153,6 @@ mod tests {
 
         let vtx = install_block_parameter(&mut genv, &mut lenv, "x".to_string());
 
-        // Parameter should be registered in LocalEnv
         assert_eq!(lenv.get_var("x"), Some(vtx));
 
         exit_block_scope(&mut genv);
@@ -79,14 +162,12 @@ mod tests {
     fn test_block_inherits_parent_scope_vars() {
         let mut genv = GlobalEnv::new();
 
-        // Set variable in top-level scope
         genv.scope_manager
             .current_scope_mut()
             .set_local_var("outer".to_string(), VertexId(100));
 
         enter_block_scope(&mut genv);
 
-        // Block should be able to lookup parent scope variables
         assert_eq!(genv.scope_manager.lookup_var("outer"), Some(VertexId(100)));
 
         exit_block_scope(&mut genv);

data/rust/src/analyzer/calls.rs

@@ -14,14 +14,15 @@ pub fn install_method_call(
     genv: &mut GlobalEnv,
     recv_vtx: VertexId,
     method_name: String,
+    arg_vtxs: Vec<VertexId>,
     location: Option<SourceLocation>,
 ) -> VertexId {
     // Create Vertex for return value
     let ret_vtx = genv.new_vertex();
 
-    // Create MethodCallBox with location
+    // 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, location);
+    let call_box = MethodCallBox::new(box_id, recv_vtx, method_name, ret_vtx, arg_vtxs, location);
     genv.register_box(box_id, Box::new(call_box));
 
     ret_vtx
@@ -37,7 +38,8 @@ mod tests {
         let mut genv = GlobalEnv::new();
 
         let recv_vtx = genv.new_source(Type::string());
-        let ret_vtx = install_method_call(&mut genv, recv_vtx, "upcase".to_string(), None);
+        let ret_vtx =
+            install_method_call(&mut genv, recv_vtx, "upcase".to_string(), vec![], None);
 
         // Return vertex should exist
         assert!(genv.get_vertex(ret_vtx).is_some());
@@ -48,7 +50,8 @@ mod tests {
         let mut genv = GlobalEnv::new();
 
         let recv_vtx = genv.new_source(Type::string());
-        let _ret_vtx = install_method_call(&mut genv, recv_vtx, "upcase".to_string(), None);
+        let _ret_vtx =
+            install_method_call(&mut genv, recv_vtx, "upcase".to_string(), vec![], None);
 
         // Box should be added
         assert_eq!(genv.box_count(), 1);