method-ray 0.1.6 → 0.1.8

data/rust/src/analyzer/loops.rs

@@ -0,0 +1,176 @@
+//! Loops - while/until loop type inference
+//!
+//! Ruby loop expressions evaluate to nil (except when break passes a value).
+//! Break value propagation is not yet supported.
+
+use crate::env::{GlobalEnv, LocalEnv};
+use crate::graph::{ChangeSet, VertexId};
+use crate::types::Type;
+use ruby_prism::{UntilNode, WhileNode};
+
+use super::install::{install_node, install_statements};
+
+/// Process WhileNode: `while predicate; statements; end`
+///
+/// Returns nil. Traverses predicate and body to register method calls
+/// and variable assignments in the type graph.
+pub(crate) fn process_while_node(
+    genv: &mut GlobalEnv,
+    lenv: &mut LocalEnv,
+    changes: &mut ChangeSet,
+    source: &str,
+    while_node: &WhileNode,
+) -> Option<VertexId> {
+    install_node(genv, lenv, changes, source, &while_node.predicate());
+
+    if let Some(stmts) = while_node.statements() {
+        install_statements(genv, lenv, changes, source, &stmts);
+    }
+
+    Some(genv.new_source(Type::Nil))
+}
+
+/// Process UntilNode: `until predicate; statements; end`
+///
+/// Returns nil. Traverses predicate and body to register method calls
+/// and variable assignments in the type graph.
+pub(crate) fn process_until_node(
+    genv: &mut GlobalEnv,
+    lenv: &mut LocalEnv,
+    changes: &mut ChangeSet,
+    source: &str,
+    until_node: &UntilNode,
+) -> Option<VertexId> {
+    install_node(genv, lenv, changes, source, &until_node.predicate());
+
+    if let Some(stmts) = until_node.statements() {
+        install_statements(genv, lenv, changes, source, &stmts);
+    }
+
+    Some(genv.new_source(Type::Nil))
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::analyzer::install::AstInstaller;
+    use crate::env::{GlobalEnv, LocalEnv};
+    use crate::graph::VertexId;
+    use crate::parser::ParseSession;
+    use crate::types::Type;
+
+    /// Helper: parse Ruby source, process with AstInstaller, and return GlobalEnv
+    fn analyze(source: &str) -> GlobalEnv {
+        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 mut genv = GlobalEnv::new();
+        let mut lenv = LocalEnv::new();
+
+        let mut installer = AstInstaller::new(&mut genv, &mut lenv, source);
+        for stmt in &program.statements().body() {
+            installer.install_node(&stmt);
+        }
+        installer.finish();
+
+        genv
+    }
+
+    /// Helper: get the type string for a vertex ID (checks both Vertex and Source)
+    fn get_type_show(genv: &GlobalEnv, vtx: VertexId) -> String {
+        if let Some(vertex) = genv.get_vertex(vtx) {
+            vertex.show()
+        } else if let Some(source) = genv.get_source(vtx) {
+            source.ty.show()
+        } else {
+            panic!("vertex {:?} not found as either Vertex or Source", vtx);
+        }
+    }
+
+    #[test]
+    fn test_while_returns_nil() {
+        let source = r#"
+class Foo
+  def bar
+    while true
+      "hello"
+    end
+  end
+end
+"#;
+        let genv = analyze(source);
+        let info = genv
+            .resolve_method(&Type::instance("Foo"), "bar")
+            .expect("Foo#bar should be registered");
+        let ret_vtx = info.return_vertex.unwrap();
+        assert_eq!(get_type_show(&genv, ret_vtx), "nil");
+    }
+
+    #[test]
+    fn test_until_returns_nil() {
+        let source = r#"
+class Foo
+  def bar
+    until false
+      "hello"
+    end
+  end
+end
+"#;
+        let genv = analyze(source);
+        let info = genv
+            .resolve_method(&Type::instance("Foo"), "bar")
+            .expect("Foo#bar should be registered");
+        let ret_vtx = info.return_vertex.unwrap();
+        assert_eq!(get_type_show(&genv, ret_vtx), "nil");
+    }
+
+    #[test]
+    fn test_while_variable_assignment_in_body() {
+        // Should not panic — variable assignment inside loop is processed
+        let source = r#"
+x = "initial"
+while true
+  x = "hello"
+end
+"#;
+        analyze(source);
+    }
+
+    #[test]
+    fn test_while_modifier_form() {
+        let source = r#"
+class Foo
+  def bar
+    x = "hello" while false
+  end
+end
+"#;
+        let genv = analyze(source);
+        let info = genv
+            .resolve_method(&Type::instance("Foo"), "bar")
+            .expect("Foo#bar should be registered");
+        let ret_vtx = info.return_vertex.unwrap();
+        assert_eq!(get_type_show(&genv, ret_vtx), "nil");
+    }
+
+    #[test]
+    fn test_begin_end_while() {
+        let source = r#"
+class Foo
+  def bar
+    begin
+      "hello"
+    end while false
+  end
+end
+"#;
+        let genv = analyze(source);
+        let info = genv
+            .resolve_method(&Type::instance("Foo"), "bar")
+            .expect("Foo#bar should be registered");
+        let ret_vtx = info.return_vertex.unwrap();
+        assert_eq!(get_type_show(&genv, ret_vtx), "nil");
+    }
+}

data/rust/src/analyzer/mod.rs

@@ -1,11 +1,14 @@
+mod assignments;
 mod attributes;
 mod blocks;
 mod calls;
 mod conditionals;
 mod definitions;
+mod exceptions;
 mod dispatch;
 mod install;
 mod literals;
+mod loops;
 mod operators;
 mod parameters;
 mod parentheses;
@@ -13,3 +16,32 @@ mod returns;
 mod variables;
 
 pub use install::AstInstaller;
+
+/// Convert ruby-prism identifier bytes to a String (lossy).
+///
+/// ruby-prism returns identifiers (method names, variable names, constant names,
+/// parameter names) as `&[u8]`. This helper provides a single conversion point
+/// used throughout the analyzer.
+///
+/// Note: Uses `from_utf8_lossy` — invalid UTF-8 bytes are replaced with U+FFFD.
+/// ruby-prism identifiers are expected to be valid UTF-8, so this should not
+/// occur in practice. Do NOT use this function for arbitrary byte data such as
+/// string literal contents.
+pub(crate) fn bytes_to_name(bytes: &[u8]) -> String {
+    String::from_utf8_lossy(bytes).to_string()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::bytes_to_name;
+
+    #[test]
+    fn test_bytes_to_name_valid_utf8() {
+        assert_eq!(bytes_to_name(b"hello"), "hello");
+    }
+
+    #[test]
+    fn test_bytes_to_name_invalid_utf8_replaced() {
+        assert_eq!(bytes_to_name(b"hello\xff"), "hello\u{FFFD}");
+    }
+}

data/rust/src/analyzer/operators.rs

@@ -1,42 +1,52 @@
-//! Operators - logical operator type inference (&&, ||)
+//! Operators - logical operator type inference (&&, ||, !)
 
 use crate::env::{GlobalEnv, LocalEnv};
 use crate::graph::{ChangeSet, VertexId};
-use ruby_prism::{AndNode, OrNode};
+use crate::types::Type;
+use ruby_prism::{AndNode, Node, OrNode};
 
 use super::install::install_node;
 
-/// Process AndNode (a && b): Union(type(a), type(b))
-///
-/// Short-circuit semantics: if `a` is falsy, returns `a`; otherwise returns `b`.
-/// Static approximation: we cannot determine truthiness at compile time,
-/// so we conservatively produce Union(type(a), type(b)).
-pub(crate) fn process_and_node(
+/// Merge two branch nodes into a union type vertex.
+fn process_binary_logical_op<'a>(
     genv: &mut GlobalEnv,
     lenv: &mut LocalEnv,
     changes: &mut ChangeSet,
     source: &str,
-    and_node: &AndNode,
+    left: Node<'a>,
+    right: Node<'a>,
 ) -> Option<VertexId> {
     let result_vtx = genv.new_vertex();
 
-    let left_vtx = install_node(genv, lenv, changes, source, &and_node.left());
-    if let Some(vtx) = left_vtx {
+    if let Some(vtx) = install_node(genv, lenv, changes, source, &left) {
         genv.add_edge(vtx, result_vtx);
     }
 
-    let right_vtx = install_node(genv, lenv, changes, source, &and_node.right());
-    if let Some(vtx) = right_vtx {
+    if let Some(vtx) = install_node(genv, lenv, changes, source, &right) {
         genv.add_edge(vtx, result_vtx);
     }
 
     Some(result_vtx)
 }
 
+/// Process AndNode (a && b): Union(type(a), type(b))
+///
+/// Runtime: if `a` is falsy, returns `a`; otherwise returns `b`.
+/// Static: conservatively produce Union(type(a), type(b)).
+pub(crate) fn process_and_node(
+    genv: &mut GlobalEnv,
+    lenv: &mut LocalEnv,
+    changes: &mut ChangeSet,
+    source: &str,
+    and_node: &AndNode,
+) -> Option<VertexId> {
+    process_binary_logical_op(genv, lenv, changes, source, and_node.left(), and_node.right())
+}
+
 /// Process OrNode (a || b): Union(type(a), type(b))
 ///
-/// Short-circuit semantics: if `a` is truthy, returns `a`; otherwise returns `b`.
-/// Static approximation: identical to AndNode — Union of both sides.
+/// Runtime: if `a` is truthy, returns `a`; otherwise returns `b`.
+/// Static: conservatively produce Union(type(a), type(b)).
 pub(crate) fn process_or_node(
     genv: &mut GlobalEnv,
     lenv: &mut LocalEnv,
@@ -44,19 +54,28 @@ pub(crate) fn process_or_node(
     source: &str,
     or_node: &OrNode,
 ) -> Option<VertexId> {
-    let result_vtx = genv.new_vertex();
-
-    let left_vtx = install_node(genv, lenv, changes, source, &or_node.left());
-    if let Some(vtx) = left_vtx {
-        genv.add_edge(vtx, result_vtx);
-    }
-
-    let right_vtx = install_node(genv, lenv, changes, source, &or_node.right());
-    if let Some(vtx) = right_vtx {
-        genv.add_edge(vtx, result_vtx);
-    }
+    process_binary_logical_op(genv, lenv, changes, source, or_node.left(), or_node.right())
+}
 
-    Some(result_vtx)
+/// Process not operator (!expr): TrueClass | FalseClass
+///
+/// In ruby-prism, `!expr` is represented as a CallNode with method name "!".
+/// Static approximation: we cannot determine the receiver's truthiness at
+/// compile time, so conservatively return TrueClass | FalseClass for any `!` call.
+/// In practice, `!nil` and `!false` are always true, but we do not track that here.
+///
+/// Receiver side effects are already analyzed by the caller (process_needs_child).
+///
+/// TODO: Ruby allows overriding `BasicObject#!`. Currently we always return
+/// TrueClass | FalseClass, ignoring user-defined `!` methods. If needed, look up
+/// the receiver's RBS definition and use its return type instead.
+pub(crate) fn process_not_operator(genv: &mut GlobalEnv) -> VertexId {
+    let result_vtx = genv.new_vertex();
+    let true_vtx = genv.new_source(Type::instance("TrueClass"));
+    let false_vtx = genv.new_source(Type::instance("FalseClass"));
+    genv.add_edge(true_vtx, result_vtx);
+    genv.add_edge(false_vtx, result_vtx);
+    result_vtx
 }
 
 #[cfg(test)]
@@ -189,4 +208,77 @@ end
         assert!(type_str.contains("Symbol"), "should contain Symbol: {}", type_str);
     }
 
+    // ============================================
+    // Not operator (!) tests
+    // ============================================
+
+    #[test]
+    fn test_not_operator_returns_boolean_union() {
+        let source = r#"
+class Foo
+  def bar
+    !true
+  end
+end
+"#;
+        let genv = analyze(source);
+        let info = genv
+            .resolve_method(&Type::instance("Foo"), "bar")
+            .expect("bar should be registered");
+        let ty = get_type_show(&genv, info.return_vertex.unwrap());
+        assert!(ty.contains("TrueClass"), "expected TrueClass in {}", ty);
+        assert!(ty.contains("FalseClass"), "expected FalseClass in {}", ty);
+    }
+
+    #[test]
+    fn test_not_operator_receiver_side_effects_analyzed() {
+        let source = r#"
+class Foo
+  def bar
+    !(1.upcase)
+  end
+end
+"#;
+        let genv = analyze(source);
+        assert!(
+            !genv.type_errors.is_empty(),
+            "expected type error for Integer#upcase"
+        );
+    }
+
+    #[test]
+    fn test_double_not_operator_union() {
+        let source = r#"
+class Foo
+  def bar
+    !!true
+  end
+end
+"#;
+        let genv = analyze(source);
+        let info = genv
+            .resolve_method(&Type::instance("Foo"), "bar")
+            .expect("bar should be registered");
+        let ty = get_type_show(&genv, info.return_vertex.unwrap());
+        assert!(ty.contains("TrueClass"), "expected TrueClass in {}", ty);
+        assert!(ty.contains("FalseClass"), "expected FalseClass in {}", ty);
+    }
+
+    #[test]
+    fn test_not_nil_returns_boolean() {
+        let source = r#"
+class Foo
+  def bar
+    !nil
+  end
+end
+"#;
+        let genv = analyze(source);
+        let info = genv
+            .resolve_method(&Type::instance("Foo"), "bar")
+            .expect("bar should be registered");
+        let ty = get_type_show(&genv, info.return_vertex.unwrap());
+        assert!(ty.contains("TrueClass"), "expected TrueClass in {}", ty);
+        assert!(ty.contains("FalseClass"), "expected FalseClass in {}", ty);
+    }
 }

data/rust/src/analyzer/parameters.rs

@@ -5,10 +5,14 @@
 //! - Creating vertices for parameters
 //! - Registering parameters as local variables in method scope
 
+use std::collections::HashMap;
+
 use crate::env::{GlobalEnv, LocalEnv};
 use crate::graph::{ChangeSet, VertexId};
 use crate::types::Type;
 
+use super::bytes_to_name;
+
 /// Install a required parameter as a local variable
 ///
 /// Required parameters start with Bot (untyped) type since we don't know
@@ -115,21 +119,23 @@ pub fn install_keyword_rest_parameter(
 
 /// 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.
+/// Returns a tuple of:
+/// - Vec<VertexId>: positional parameter vertices (required and optional)
+/// - HashMap<String, VertexId>: keyword parameter vertices (name → vertex)
 pub(crate) fn install_parameters(
     genv: &mut GlobalEnv,
     lenv: &mut LocalEnv,
     changes: &mut ChangeSet,
     source: &str,
     params_node: &ruby_prism::ParametersNode,
-) -> Vec<VertexId> {
+) -> (Vec<VertexId>, HashMap<String, VertexId>) {
     let mut param_vtxs = Vec::new();
+    let mut keyword_param_vtxs: HashMap<String, VertexId> = HashMap::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 name = bytes_to_name(req_param.name().as_slice());
             let vtx = install_required_parameter(genv, lenv, name);
             param_vtxs.push(vtx);
         }
@@ -138,7 +144,7 @@ pub(crate) fn install_parameters(
     // 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 name = bytes_to_name(opt_param.name().as_slice());
             let default_value = opt_param.value();
 
             let vtx = if let Some(default_vtx) =
@@ -157,24 +163,46 @@ pub(crate) fn install_parameters(
     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();
+                let name = bytes_to_name(name_id.as_slice());
                 install_rest_parameter(genv, lenv, name);
             }
         }
     }
 
+    // Keyword parameters: def foo(name:, age: 0)
+    // Reuses install_required_parameter / install_optional_parameter
+    // since the logic is identical for positional and keyword parameters.
+    for node in params_node.keywords().iter() {
+        if let Some(req_kw) = node.as_required_keyword_parameter_node() {
+            let name = bytes_to_name(req_kw.name().as_slice());
+            let vtx = install_required_parameter(genv, lenv, name.clone());
+            keyword_param_vtxs.insert(name, vtx);
+        } else if let Some(opt_kw) = node.as_optional_keyword_parameter_node() {
+            let name = bytes_to_name(opt_kw.name().as_slice());
+            let default_value = opt_kw.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.clone(), default_vtx)
+            } else {
+                install_required_parameter(genv, lenv, name.clone())
+            };
+            keyword_param_vtxs.insert(name, vtx);
+        }
+    }
+
     // Keyword rest parameter: def foo(**kwargs)
-    // Not included in param_vtxs (keyword args need special handling)
+    // Not included in keyword_param_vtxs (collects all remaining keywords)
     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();
+                let name = bytes_to_name(name_id.as_slice());
                 install_keyword_rest_parameter(genv, lenv, name);
             }
         }
     }
 
-    param_vtxs
+    (param_vtxs, keyword_param_vtxs)
 }
 
 #[cfg(test)]
@@ -215,4 +243,27 @@ mod tests {
         assert_ne!(vtx_b, vtx_c);
         assert_ne!(vtx_a, vtx_c);
     }
+
+    #[test]
+    fn test_install_optional_parameter_inherits_default_type() {
+        let mut genv = GlobalEnv::new();
+        let mut lenv = LocalEnv::new();
+        let mut changes = ChangeSet::new();
+
+        // Default value: 0 (Integer)
+        let default_vtx = genv.new_source(Type::integer());
+        let vtx = install_optional_parameter(
+            &mut genv,
+            &mut lenv,
+            &mut changes,
+            "age".to_string(),
+            default_vtx,
+        );
+
+        assert_eq!(lenv.get_var("age"), Some(vtx));
+
+        // Type should propagate from default value
+        let vertex = genv.get_vertex(vtx).unwrap();
+        assert_eq!(vertex.show(), "Integer");
+    }
 }

data/rust/src/cache/rbs_cache.rs

@@ -37,7 +37,6 @@ impl SerializableMethodInfo {
     }
 }
 
-#[allow(dead_code)]
 impl RbsCache {
     /// Get user cache file path (in ~/.cache/methodray/)
     pub fn cache_path() -> Result<PathBuf> {

data/rust/src/cli/commands.rs

@@ -1,7 +1,7 @@
 //! CLI command implementations
 
 use anyhow::Result;
-use std::path::PathBuf;
+use std::path::Path;
 
 use crate::cache::RbsCache;
 use crate::checker::FileChecker;
@@ -9,7 +9,7 @@ use crate::diagnostics;
 
 /// Check a single Ruby file for type errors
 /// Returns Ok(true) if no errors, Ok(false) if errors found
-pub fn check_single_file(file_path: &PathBuf, verbose: bool) -> Result<bool> {
+pub fn check_single_file(file_path: &Path, verbose: bool) -> Result<bool> {
     let checker = FileChecker::new()?;
     let diagnostics = checker.check_file(file_path)?;
 
@@ -38,7 +38,7 @@ pub fn check_project(_verbose: bool) -> Result<()> {
 }
 
 /// Watch a file for changes and re-check on modifications
-pub fn watch_file(file_path: &PathBuf) -> Result<()> {
+pub fn watch_file(file_path: &Path) -> Result<()> {
     use notify::{Config, RecommendedWatcher, RecursiveMode, Watcher};
     use std::sync::mpsc::channel;
     use std::time::Duration;

data/rust/src/diagnostics/diagnostic.rs

@@ -2,7 +2,6 @@ use std::path::PathBuf;
 
 /// Diagnostic severity level (LSP compatible)
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
-#[allow(dead_code)]
 pub enum DiagnosticLevel {
     Error,
     Warning,
@@ -28,7 +27,6 @@ pub struct Location {
 
 /// Type checking diagnostic
 #[derive(Debug, Clone)]
-#[allow(dead_code)]
 pub struct Diagnostic {
     pub location: Location,
     pub level: DiagnosticLevel,
@@ -36,7 +34,6 @@ pub struct Diagnostic {
     pub code: Option<String>, // e.g., "E001"
 }
 
-#[allow(dead_code)]
 impl Diagnostic {
     /// Create an error diagnostic
     pub fn error(location: Location, message: String) -> Self {

data/rust/src/diagnostics/formatter.rs

@@ -8,7 +8,6 @@ use std::path::Path;
 /// ```text
 /// app/models/user.rb:10:5: error: undefined method `upcase` for Integer
 /// ```
-#[allow(dead_code)]
 pub fn format_diagnostics(diagnostics: &[Diagnostic]) -> String {
     diagnostics
         .iter()

data/rust/src/env/box_manager.rs

@@ -6,7 +6,6 @@ use crate::graph::{BoxId, BoxTrait};
 use std::collections::{HashMap, HashSet, VecDeque};
 
 /// Manages boxes and their execution queue
-#[allow(dead_code)]
 pub struct BoxManager {
     /// All registered boxes
     pub boxes: HashMap<BoxId, Box<dyn BoxTrait>>,
@@ -24,7 +23,6 @@ impl Default for BoxManager {
     }
 }
 
-#[allow(dead_code)]
 impl BoxManager {
     /// Create a new empty box manager
     pub fn new() -> Self {
@@ -37,8 +35,8 @@ impl BoxManager {
     }
 
     /// Get a box by ID
-    pub fn get(&self, id: BoxId) -> Option<&Box<dyn BoxTrait>> {
-        self.boxes.get(&id)
+    pub fn get(&self, id: BoxId) -> Option<&dyn BoxTrait> {
+        self.boxes.get(&id).map(|b| b.as_ref())
     }
 
     /// Remove a box and return it (for temporary mutation)