method-ray 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b03f7efedd583d2cda9e59cd651ded78d5357c53eb06eac8980aae25db0529de
-  data.tar.gz: c02996cc2a511f800d34cec0ce46744c6ae2bddb8974e361f994a332b898c467
+  metadata.gz: c950d346d7e01dfcf74b912ee1677450b9ea3d95c3baac937062cc8bf4363163
+  data.tar.gz: d9804ea668007c228bb12078ebaa3ec7e4c3b37daa372b2a801765b90978136a
 SHA512:
-  metadata.gz: 3aa19e8a26274f5d8c7b5b746e67f10d4e47ac281852251c737ebed4f933b5426e8b842d575f26110ee279fc48079a1dc382e78b2a184e0d4211d241dabae77a
-  data.tar.gz: '08e6b8bf49475c874538c007b52fec615459eb0c376357e1b2429868a67885eb695d261ba02d078b7fb0835321b92e84f06a6ac5366066379229b0e78072d786'
+  metadata.gz: 1a572ea77523293d586c6acd284994206f1b4b678ede730f50fe619f98762f1c215daf5b8e899400f3872769078aa033bd6cea701515533acfe11d7695e0fd26
+  data.tar.gz: 2f20387f762e32766281f6813971b3f546f8cb6476482cbe13d3cfb1fe03e6761e2304be3a5eeade1cb8261d7e5197a1416e3f0cfad280450b54a16acdddacb1

data/CHANGELOG.md

@@ -5,6 +5,30 @@ 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.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 +54,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.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.3"
 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.3'
 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.3"
 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/blocks.rs

@@ -0,0 +1,94 @@
+//! 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::VertexId;
+
+use super::parameters::install_required_parameter;
+
+/// 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) {
+    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) {
+    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_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;
+
+        // 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);
+    }
+
+    #[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());
+
+        // Parameter should be registered in LocalEnv
+        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();
+
+        // 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/definitions.rs

@@ -1,39 +1,85 @@
-//! Definition Handlers - Processing Ruby class/method definitions
+//! Definition Handlers - Processing Ruby class/method/module definitions
 //!
 //! This module is responsible for:
 //! - Class definition scope management (class Foo ... end)
-//! - Method definition scope management (def bar ... end)
-//! - Extracting class names from AST nodes
+//! - Module definition scope management (module Bar ... end)
+//! - Method definition scope management (def baz ... end)
+//! - Extracting class/module names from AST nodes (including qualified names like Api::User)
 
 use crate::env::GlobalEnv;
+use ruby_prism::Node;
 
 /// Install class definition
 pub fn install_class(genv: &mut GlobalEnv, class_name: String) {
     genv.enter_class(class_name);
 }
 
+/// Install module definition
+pub fn install_module(genv: &mut GlobalEnv, module_name: String) {
+    genv.enter_module(module_name);
+}
+
 /// Install method definition
 pub fn install_method(genv: &mut GlobalEnv, method_name: String) {
     genv.enter_method(method_name);
 }
 
-/// Exit current scope (class or method)
+/// Exit current scope (class, module, or method)
 pub fn exit_scope(genv: &mut GlobalEnv) {
     genv.exit_scope();
 }
 
 /// Extract class name from ClassNode
+/// Supports both simple names (User) and qualified names (Api::V1::User)
 pub fn extract_class_name(class_node: &ruby_prism::ClassNode) -> String {
-    if let Some(constant_read) = class_node.constant_path().as_constant_read_node() {
-        String::from_utf8_lossy(constant_read.name().as_slice()).to_string()
-    } else {
-        "UnknownClass".to_string()
+    extract_constant_path(&class_node.constant_path()).unwrap_or_else(|| "UnknownClass".to_string())
+}
+
+/// Extract module name from ModuleNode
+/// Supports both simple names (Utils) and qualified names (Api::V1::Utils)
+pub fn extract_module_name(module_node: &ruby_prism::ModuleNode) -> String {
+    extract_constant_path(&module_node.constant_path())
+        .unwrap_or_else(|| "UnknownModule".to_string())
+}
+
+/// Extract constant path from a Node (handles both ConstantReadNode and ConstantPathNode)
+///
+/// Examples:
+/// - `User` (ConstantReadNode) → "User"
+/// - `Api::User` (ConstantPathNode) → "Api::User"
+/// - `Api::V1::User` (nested ConstantPathNode) → "Api::V1::User"
+/// - `::Api::User` (absolute path with COLON3) → "Api::User"
+fn extract_constant_path(node: &Node) -> Option<String> {
+    // Simple constant read: `User`
+    if let Some(constant_read) = node.as_constant_read_node() {
+        return Some(String::from_utf8_lossy(constant_read.name().as_slice()).to_string());
     }
+
+    // Constant path: `Api::User` or `Api::V1::User`
+    if let Some(constant_path) = node.as_constant_path_node() {
+        // name() returns Option<ConstantId>, use as_slice() to get &[u8]
+        let name = constant_path
+            .name()
+            .map(|id| String::from_utf8_lossy(id.as_slice()).to_string())?;
+
+        // Get parent path if exists
+        if let Some(parent_node) = constant_path.parent() {
+            if let Some(parent_path) = extract_constant_path(&parent_node) {
+                return Some(format!("{}::{}", parent_path, name));
+            }
+        }
+
+        // No parent (absolute path like `::User`)
+        return Some(name);
+    }
+
+    None
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::parser::ParseSession;
 
     #[test]
     fn test_enter_exit_class_scope() {
@@ -49,6 +95,20 @@ mod tests {
         assert_eq!(genv.scope_manager.current_class_name(), None);
     }
 
+    #[test]
+    fn test_enter_exit_module_scope() {
+        let mut genv = GlobalEnv::new();
+
+        install_module(&mut genv, "Utils".to_string());
+        assert_eq!(
+            genv.scope_manager.current_module_name(),
+            Some("Utils".to_string())
+        );
+
+        exit_scope(&mut genv);
+        assert_eq!(genv.scope_manager.current_module_name(), None);
+    }
+
     #[test]
     fn test_nested_method_scope() {
         let mut genv = GlobalEnv::new();
@@ -67,4 +127,93 @@ mod tests {
 
         assert_eq!(genv.scope_manager.current_class_name(), None);
     }
+
+    #[test]
+    fn test_method_in_module() {
+        let mut genv = GlobalEnv::new();
+
+        install_module(&mut genv, "Helpers".to_string());
+        install_method(&mut genv, "format".to_string());
+
+        // Should find module context from within method
+        assert_eq!(
+            genv.scope_manager.current_module_name(),
+            Some("Helpers".to_string())
+        );
+
+        exit_scope(&mut genv); // exit method
+        exit_scope(&mut genv); // exit module
+
+        assert_eq!(genv.scope_manager.current_module_name(), None);
+    }
+
+    #[test]
+    fn test_extract_simple_class_name() {
+        let source = "class User; end";
+        let session = ParseSession::new();
+        let parse_result = session.parse_source(source, "test.rb").unwrap();
+        let root = parse_result.node();
+        let program = root.as_program_node().unwrap();
+        let stmt = program.statements().body().first().unwrap();
+        let class_node = stmt.as_class_node().unwrap();
+
+        let name = extract_class_name(&class_node);
+        assert_eq!(name, "User");
+    }
+
+    #[test]
+    fn test_extract_qualified_class_name() {
+        let source = "class Api::User; end";
+        let session = ParseSession::new();
+        let parse_result = session.parse_source(source, "test.rb").unwrap();
+        let root = parse_result.node();
+        let program = root.as_program_node().unwrap();
+        let stmt = program.statements().body().first().unwrap();
+        let class_node = stmt.as_class_node().unwrap();
+
+        let name = extract_class_name(&class_node);
+        assert_eq!(name, "Api::User");
+    }
+
+    #[test]
+    fn test_extract_deeply_qualified_class_name() {
+        let source = "class Api::V1::Admin::User; end";
+        let session = ParseSession::new();
+        let parse_result = session.parse_source(source, "test.rb").unwrap();
+        let root = parse_result.node();
+        let program = root.as_program_node().unwrap();
+        let stmt = program.statements().body().first().unwrap();
+        let class_node = stmt.as_class_node().unwrap();
+
+        let name = extract_class_name(&class_node);
+        assert_eq!(name, "Api::V1::Admin::User");
+    }
+
+    #[test]
+    fn test_extract_simple_module_name() {
+        let source = "module Utils; end";
+        let session = ParseSession::new();
+        let parse_result = session.parse_source(source, "test.rb").unwrap();
+        let root = parse_result.node();
+        let program = root.as_program_node().unwrap();
+        let stmt = program.statements().body().first().unwrap();
+        let module_node = stmt.as_module_node().unwrap();
+
+        let name = extract_module_name(&module_node);
+        assert_eq!(name, "Utils");
+    }
+
+    #[test]
+    fn test_extract_qualified_module_name() {
+        let source = "module Api::V1; end";
+        let session = ParseSession::new();
+        let parse_result = session.parse_source(source, "test.rb").unwrap();
+        let root = parse_result.node();
+        let program = root.as_program_node().unwrap();
+        let stmt = program.statements().body().first().unwrap();
+        let module_node = stmt.as_module_node().unwrap();
+
+        let name = extract_module_name(&module_node);
+        assert_eq!(name, "Api::V1");
+    }
 }

data/rust/src/analyzer/dispatch.rs

@@ -9,7 +9,6 @@ use crate::source_map::SourceLocation;
 use ruby_prism::Node;
 
 use super::calls::install_method_call;
-use super::literals::install_literal;
 use super::variables::{
     install_ivar_read, install_ivar_write, install_local_var_read, install_local_var_write,
     install_self,
@@ -34,10 +33,15 @@ pub enum NeedsChildKind<'a> {
         receiver: Node<'a>,
         method_name: String,
         location: SourceLocation,
+        /// Optional block attached to the method call
+        block: Option<Node<'a>>,
     },
 }
 
 /// First pass: check if node can be handled immediately without child processing
+///
+/// Note: Literals (including Array) are handled in install.rs via install_literal
+/// because Array literals need child processing for element type inference.
 pub fn dispatch_simple(genv: &mut GlobalEnv, lenv: &mut LocalEnv, node: &Node) -> DispatchResult {
     // Instance variable read: @name
     if let Some(ivar_read) = node.as_instance_variable_read_node() {
@@ -62,11 +66,6 @@ pub fn dispatch_simple(genv: &mut GlobalEnv, lenv: &mut LocalEnv, node: &Node) -
         };
     }
 
-    // Literals (String, Integer, Array, Hash, nil, true, false, Symbol)
-    if let Some(vtx) = install_literal(genv, node) {
-        return DispatchResult::Vertex(vtx);
-    }
-
     DispatchResult::NotHandled
 }
 
@@ -90,16 +89,25 @@ pub fn dispatch_needs_child<'a>(node: &Node<'a>, source: &str) -> Option<NeedsCh
         });
     }
 
-    // Method call: x.upcase
+    // Method call: x.upcase or x.each { |i| ... }
     if let Some(call_node) = node.as_call_node() {
         if let Some(receiver) = call_node.receiver() {
             let method_name = String::from_utf8_lossy(call_node.name().as_slice()).to_string();
+            // Use call_operator_loc (.) for error position, fallback to node location
+            let prism_location = call_node
+                .call_operator_loc()
+                .unwrap_or_else(|| node.location());
             let location =
-                SourceLocation::from_prism_location_with_source(&node.location(), source);
+                SourceLocation::from_prism_location_with_source(&prism_location, source);
+
+            // Get block if present (e.g., `x.each { |i| ... }`)
+            let block = call_node.block();
+
             return Some(NeedsChildKind::MethodCall {
                 receiver,
                 method_name,
                 location,
+                block,
             });
         }
     }