method-ray 0.1.3 → 0.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c950d346d7e01dfcf74b912ee1677450b9ea3d95c3baac937062cc8bf4363163
-  data.tar.gz: d9804ea668007c228bb12078ebaa3ec7e4c3b37daa372b2a801765b90978136a
+  metadata.gz: 1d261070d86a9c7277779eeccc80ac967aeac41ac66fb760e2f76bcc485a1679
+  data.tar.gz: 7bd048bc66105308344fff40a99af2afca5ce15d3550affff034918e50044ca4
 SHA512:
-  metadata.gz: 1a572ea77523293d586c6acd284994206f1b4b678ede730f50fe619f98762f1c215daf5b8e899400f3872769078aa033bd6cea701515533acfe11d7695e0fd26
-  data.tar.gz: 2f20387f762e32766281f6813971b3f546f8cb6476482cbe13d3cfb1fe03e6761e2304be3a5eeade1cb8261d7e5197a1416e3f0cfad280450b54a16acdddacb1
+  metadata.gz: 5279ea150a536357cceded2ef2576f1a459b51b218b23b9972582b9763609220567d0cfaa870736a446a926420a3d908dc96fa437d56be49fdc9c1f7a8877c63
+  data.tar.gz: f2f80b3c71ba3190221098c048c5d8b4c576f3c35e1dae0f16022dcea873a577cdc64d2e522866e6290419198e7f63a089dd91e2b3220c5486069d389fec9cbd

data/CHANGELOG.md

@@ -5,6 +5,41 @@ 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.5] - 2026-02-23
+
+### Added
+
+- String interpolation type inference (`InterpolatedStringNode`, `InterpolatedSymbolNode`, `InterpolatedRegularExpressionNode`) ([#26](https://github.com/dak2/method-ray/pull/26))
+- Parentheses node type inference for parenthesized expressions ([#27](https://github.com/dak2/method-ray/pull/27))
+- Qualified name method registration to resolve namespace conflicts ([#28](https://github.com/dak2/method-ray/pull/28))
+- Return statement type inference with merge vertex pattern ([#29](https://github.com/dak2/method-ray/pull/29))
+- Ternary operator type inference tests ([#30](https://github.com/dak2/method-ray/pull/30))
+- Logical operator (`&&`/`||`) type inference with union type approximation ([#31](https://github.com/dak2/method-ray/pull/31))
+- Class method (`def self.foo`) type registration and checking ([#32](https://github.com/dak2/method-ray/pull/32))
+
+### Changed
+
+- Removed stateless `Analyzer` class and simplified Ruby FFI surface to module functions ([#33](https://github.com/dak2/method-ray/pull/33))
+
+### Deprecated
+
+- `clear_cache` command ([#25](https://github.com/dak2/method-ray/pull/25))
+
+## [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 +89,8 @@ 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.5]: https://github.com/dak2/method-ray/releases/tag/v0.1.5
+[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.5"
 edition = "2021"
 
 [lib]

data/ext/src/lib.rs

@@ -2,7 +2,7 @@
 //!
 //! This module provides the Ruby gem interface using magnus.
 
-use magnus::{function, method, prelude::*, Error, Ruby};
+use magnus::{function, prelude::*, Error, Ruby};
 use methodray_core::{
     analyzer::AstInstaller,
     env::{GlobalEnv, LocalEnv},
@@ -10,86 +10,65 @@ use methodray_core::{
     rbs,
 };
 
-#[magnus::wrap(class = "MethodRay::Analyzer")]
-pub struct Analyzer {
-    #[allow(dead_code)]
-    path: String,
-}
-
-impl Analyzer {
-    fn new(path: String) -> Self {
-        Self { path }
-    }
-
-    fn version(&self) -> String {
-        "0.1.0".to_string()
-    }
-
-    /// Execute type inference
-    fn infer_types(&self, source: String) -> Result<String, Error> {
-        // Parse
-        let session = ParseSession::new();
-        let parse_result = session.parse_source(&source, "source.rb").map_err(|e| {
-            let ruby = unsafe { Ruby::get_unchecked() };
-            Error::new(ruby.exception_runtime_error(), e.to_string())
-        })?;
+/// Type inference (public module function)
+fn infer_types(source: String) -> Result<String, Error> {
+    // Parse
+    let session = ParseSession::new();
+    let parse_result = session.parse_source(&source, "source.rb").map_err(|e| {
+        let ruby = unsafe { Ruby::get_unchecked() };
+        Error::new(ruby.exception_runtime_error(), e.to_string())
+    })?;
 
-        // Build graph
-        let mut genv = GlobalEnv::new();
+    // Build graph
+    let mut genv = GlobalEnv::new();
 
-        // Register built-in methods from RBS
-        let ruby = unsafe { Ruby::get_unchecked() };
-        rbs::register_rbs_methods(&mut genv, &ruby)?;
+    // Register built-in methods from RBS
+    let ruby = unsafe { Ruby::get_unchecked() };
+    rbs::register_rbs_methods(&mut genv, &ruby)?;
 
-        let mut lenv = LocalEnv::new();
-        let mut installer = AstInstaller::new(&mut genv, &mut lenv, &source);
+    let mut lenv = LocalEnv::new();
+    let mut installer = AstInstaller::new(&mut genv, &mut lenv, &source);
 
-        // Process AST
-        let root = parse_result.node();
-        if let Some(program_node) = root.as_program_node() {
-            let statements = program_node.statements();
-            for stmt in &statements.body() {
-                installer.install_node(&stmt);
-            }
+    // Process AST
+    let root = parse_result.node();
+    if let Some(program_node) = root.as_program_node() {
+        let statements = program_node.statements();
+        for stmt in &statements.body() {
+            installer.install_node(&stmt);
         }
+    }
 
-        installer.finish();
+    installer.finish();
 
-        // Return results as string
-        let mut results = Vec::new();
-        for (var_name, vtx_id) in lenv.all_vars() {
-            if let Some(vtx) = genv.get_vertex(*vtx_id) {
-                results.push(format!("{}: {}", var_name, vtx.show()));
-            }
+    // Return results as string
+    let mut results = Vec::new();
+    for (var_name, vtx_id) in lenv.all_vars() {
+        if let Some(vtx) = genv.get_vertex(*vtx_id) {
+            results.push(format!("{}: {}", var_name, vtx.show()));
         }
-
-        Ok(results.join("\n"))
     }
+
+    Ok(results.join("\n"))
 }
 
-/// Setup function that only generates RBS cache
-/// This is used during gem build to pre-generate the cache
-fn setup() -> Result<String, Error> {
+/// RBS cache generation (executed when requiring methodray/setup)
+fn setup() -> Result<(), Error> {
     let ruby = unsafe { Ruby::get_unchecked() };
     let mut genv = GlobalEnv::new();
 
     // This will load RBS and save to cache if not already cached
-    let count = rbs::register_rbs_methods(&mut genv, &ruby)?;
+    rbs::register_rbs_methods(&mut genv, &ruby)?;
 
-    Ok(format!("RBS cache generated with {} methods", count))
+    Ok(())
 }
 
 #[magnus::init]
 fn init(ruby: &Ruby) -> Result<(), Error> {
     let module = ruby.define_module("MethodRay")?;
-    let class = module.define_class("Analyzer", ruby.class_object())?;
-
-    class.define_singleton_method("new", function!(Analyzer::new, 1))?;
-    class.define_method("version", method!(Analyzer::version, 0))?;
-    class.define_method("infer_types", method!(Analyzer::infer_types, 1))?;
+    module.define_singleton_method("infer_types", function!(infer_types, 1))?;
 
-    // Module-level setup function for cache generation
-    module.define_singleton_method("setup", function!(setup, 0))?;
+    // require methodray/setup to generate RBS cache on Ruby side
+    setup()?;
 
     Ok(())
 }

data/lib/methodray/cli.rb

@@ -17,6 +17,7 @@ module MethodRay
       when 'watch'
         Commands.watch(args)
       when 'clear-cache'
+        warn "WARNING: 'clear-cache' is deprecated and will be removed in a future version."
         Commands.clear_cache(args)
       else
         puts "Unknown command: #{command}"

data/lib/methodray/commands.rb

@@ -14,7 +14,6 @@ module MethodRay
             methodray version                 # Show version
             methodray check [FILE] [OPTIONS]  # Type check a Ruby file
             methodray watch FILE              # Watch file for changes and auto-check
-            methodray clear-cache             # Clear RBS method cache
 
           Examples:
             methodray check app/models/user.rb

data/lib/methodray/version.rb

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

data/rust/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "methodray-core"
-version = "0.1.3"
+version = "0.1.5"
 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(qualified_name) = genv.scope_manager.current_qualified_name() else {
+        return;
+    };
+    let recv_ty = Type::instance(&qualified_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);