method-ray 0.1.2 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b03f7efedd583d2cda9e59cd651ded78d5357c53eb06eac8980aae25db0529de
-  data.tar.gz: c02996cc2a511f800d34cec0ce46744c6ae2bddb8974e361f994a332b898c467
+  metadata.gz: 1a219edf198245163ff36fbcc9e211dbfea2d5e5f41a467ee24636286967f4b9
+  data.tar.gz: 7a82426e9c5b0ba53a2d1ca8bab90da2a4b4eb58316af7cfb8a576dc6dc28b64
 SHA512:
-  metadata.gz: 3aa19e8a26274f5d8c7b5b746e67f10d4e47ac281852251c737ebed4f933b5426e8b842d575f26110ee279fc48079a1dc382e78b2a184e0d4211d241dabae77a
-  data.tar.gz: '08e6b8bf49475c874538c007b52fec615459eb0c376357e1b2429868a67885eb695d261ba02d078b7fb0835321b92e84f06a6ac5366066379229b0e78072d786'
+  metadata.gz: cac68a8608631ce81f145b17743ff7ec519e24f1ac2b92c90732d3f9fedd4badb26715fd5120b8a648fd574313383ac2dbd02d71cdfe98004ffafe5714e39cf3
+  data.tar.gz: ded1386c832dfc9784c360d3685ce3431437d7cae1c155e02dc6606e3e155789f9f2ad42d5e4285aed6c8cb1dbf8231ac8f81392bf25a0536e3fd18e882537f3

data/CHANGELOG.md

@@ -5,6 +5,45 @@ 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
+
+- Method parameter type inference support ([#3](https://github.com/dak2/method-ray/pull/3))
+- Block parameter type variable resolution ([#4](https://github.com/dak2/method-ray/pull/4))
+- Module scope support ([#6](https://github.com/dak2/method-ray/pull/6))
+- Fully qualified name support for nested classes/modules ([#7](https://github.com/dak2/method-ray/pull/7))
+- Float type support ([#8](https://github.com/dak2/method-ray/pull/8))
+- Regexp type support ([#9](https://github.com/dak2/method-ray/pull/9))
+- Range type support ([#10](https://github.com/dak2/method-ray/pull/10))
+- Generic type inference for Range, Hash, and nested Array ([#11](https://github.com/dak2/method-ray/pull/11))
+
+### Fixed
+
+- Call operator location ([#12](https://github.com/dak2/method-ray/pull/12))
+- Memory leak ([#13](https://github.com/dak2/method-ray/pull/13))
+
+### Changed
+
+- Extract BinaryLocator class from Commands module ([#5](https://github.com/dak2/method-ray/pull/5))
+- Migrate Rust integration tests to Ruby CLI and Rust unit tests ([#14](https://github.com/dak2/method-ray/pull/14))
+- Remove unnecessary test files and logs ([#1](https://github.com/dak2/method-ray/pull/1), [#15](https://github.com/dak2/method-ray/pull/15))
+
 ## [0.1.2] - 2025-01-19
 
 ### Added
@@ -30,6 +69,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.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
 [0.1.0]: https://github.com/dak2/method-ray/releases/tag/v0.1.0

data/README.md

@@ -2,6 +2,8 @@
 
 A fast static callable method checker for Ruby code.
 
+No type annotations required, just check callable methods in your Ruby files.
+
 ## Requirements
 
 Method-Ray supports Ruby 3.4 or later.
@@ -14,7 +16,7 @@ gem install methodray
 
 ## Quick Start
 
-### VSCode Extension
+### VSCode Extension (under development)
 
 1. Install the [Method-Ray VSCode extension](https://github.com/dak2/method-ray-vscode)
 2. Open a Ruby file in VSCode
@@ -30,6 +32,30 @@ bundle exec methodray check app/models/user.rb
 bundle exec methodray watch app/models/user.rb
 ```
 
+#### Example
+
+`methodray check <file>`: Performs static type checking on the specified Ruby file.
+
+
+```ruby
+class User
+  def greeting
+    name = "Alice"
+    message = name.abs
+    message
+  end
+end
+```
+
+This will output:
+
+```
+$ bundle exec methodray check app/models/user.rb
+app/models/user.rb:4:19: error: undefined method `abs` for String
+       message = name.abs
+                     ^
+```
+
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at this repository!

data/ext/Cargo.toml

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

data/ext/src/lib.rs

@@ -6,7 +6,8 @@ use magnus::{function, method, prelude::*, Error, Ruby};
 use methodray_core::{
     analyzer::AstInstaller,
     env::{GlobalEnv, LocalEnv},
-    parser, rbs,
+    parser::ParseSession,
+    rbs,
 };
 
 #[magnus::wrap(class = "MethodRay::Analyzer")]
@@ -27,11 +28,11 @@ impl Analyzer {
     /// Execute type inference
     fn infer_types(&self, source: String) -> Result<String, Error> {
         // Parse
-        let parse_result =
-            parser::parse_ruby_source(&source, "source.rb".to_string()).map_err(|e| {
-                let ruby = unsafe { Ruby::get_unchecked() };
-                Error::new(ruby.exception_runtime_error(), e.to_string())
-            })?;
+        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();

data/lib/methodray/binary_locator.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module MethodRay
+  class BinaryLocator
+    LIB_DIR = __dir__
+
+    def initialize
+      @binary_name = Gem.win_platform? ? 'methodray-cli.exe' : 'methodray-cli'
+      @legacy_binary_name = Gem.win_platform? ? 'methodray.exe' : 'methodray'
+    end
+
+    def find
+      candidates.find { |path| File.executable?(path) }
+    end
+
+    private
+
+    def candidates
+      [
+        # CLI binary built during gem install (lib/methodray directory)
+        File.expand_path(@binary_name, LIB_DIR),
+        # Development: target/release (project root)
+        File.expand_path("../../target/release/#{@binary_name}", LIB_DIR),
+        # Development: rust/target/release (legacy standalone binary)
+        File.expand_path("../../rust/target/release/#{@legacy_binary_name}", LIB_DIR)
+      ]
+    end
+  end
+end

data/lib/methodray/commands.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
+require_relative 'binary_locator'
+
 module MethodRay
   module Commands
-    COMMANDS_DIR = __dir__
-
     class << self
       def help
         puts <<~HELP
@@ -41,7 +41,7 @@ module MethodRay
       private
 
       def exec_rust_cli(command, args)
-        binary_path = find_rust_binary
+        binary_path = BinaryLocator.new.find
 
         unless binary_path
           warn 'Error: CLI binary not found.'
@@ -56,23 +56,6 @@ module MethodRay
 
         exec(binary_path, command, *args)
       end
-
-      def find_rust_binary
-        # Platform-specific binary name
-        cli_binary = Gem.win_platform? ? 'methodray-cli.exe' : 'methodray-cli'
-        legacy_binary = Gem.win_platform? ? 'methodray.exe' : 'methodray'
-
-        candidates = [
-          # CLI binary built during gem install (lib/methodray directory)
-          File.expand_path(cli_binary, COMMANDS_DIR),
-          # Development: target/release (project root)
-          File.expand_path("../../target/release/#{cli_binary}", COMMANDS_DIR),
-          # Development: rust/target/release (legacy standalone binary)
-          File.expand_path("../../rust/target/release/#{legacy_binary}", COMMANDS_DIR)
-        ]
-
-        candidates.find { |path| File.executable?(path) }
-      end
     end
   end
 end

data/lib/methodray/version.rb

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

data/lib/methodray.rb

@@ -2,7 +2,7 @@
 
 require 'rbs'
 require_relative 'methodray/version'
-require_relative 'methodray/methodray' # ネイティブ拡張
+require_relative 'methodray/methodray'
 
 module MethodRay
   class Error < StandardError; end

data/rust/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "methodray-core"
-version = "0.1.0"
+version = "0.1.4"
 edition = "2021"
 
 [lib]
@@ -18,6 +18,8 @@ path = "src/lsp/main.rs"
 required-features = ["lsp"]
 
 [dependencies]
+bumpalo = "3.14"
+smallvec = "1.13"
 rayon = "1.10"
 walkdir = "2.5"
 anyhow = "1.0"

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

@@ -0,0 +1,175 @@
+//! Block Handlers - Processing Ruby blocks
+//!
+//! This module is responsible for:
+//! - Processing BlockNode (e.g., `{ |x| x.to_s }` or `do |x| x.to_s end`)
+//! - Registering block parameters as local variables
+//! - Managing block scope
+
+use crate::env::{GlobalEnv, LocalEnv, ScopeKind};
+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);
+
+    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
+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
+fn exit_block_scope(genv: &mut GlobalEnv) {
+    genv.scope_manager.exit_scope();
+}
+
+/// 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)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_enter_exit_block_scope() {
+        let mut genv = GlobalEnv::new();
+
+        let initial_scope_id = genv.scope_manager.current_scope().id;
+
+        enter_block_scope(&mut genv);
+        let block_scope_id = genv.scope_manager.current_scope().id;
+
+        assert_ne!(initial_scope_id, block_scope_id);
+
+        exit_block_scope(&mut genv);
+
+        assert_eq!(genv.scope_manager.current_scope().id, initial_scope_id);
+    }
+
+    #[test]
+    fn test_install_block_parameter() {
+        let mut genv = GlobalEnv::new();
+        let mut lenv = LocalEnv::new();
+
+        enter_block_scope(&mut genv);
+
+        let vtx = install_block_parameter(&mut genv, &mut lenv, "x".to_string());
+
+        assert_eq!(lenv.get_var("x"), Some(vtx));
+
+        exit_block_scope(&mut genv);
+    }
+
+    #[test]
+    fn test_block_inherits_parent_scope_vars() {
+        let mut genv = GlobalEnv::new();
+
+        genv.scope_manager
+            .current_scope_mut()
+            .set_local_var("outer".to_string(), VertexId(100));
+
+        enter_block_scope(&mut genv);
+
+        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);