method-ray 0.1.10 → 0.2.0

data/core/src/analyzer/dispatch.rs

@@ -13,9 +13,11 @@ use ruby_prism::Node;
 
 use super::bytes_to_name;
 use super::calls::install_method_call;
+use super::compound_assignments::{CompoundOp, CompoundVarKind};
 use super::variables::{
-    install_ivar_read, install_ivar_write, install_local_var_read, install_local_var_write,
-    install_self,
+    install_class_var_read, install_class_var_write, install_constant_read, install_constant_write,
+    install_global_var_read, install_global_var_write, install_ivar_read, install_ivar_write,
+    install_local_var_read, install_local_var_write, install_self,
 };
 
 /// Collect positional and keyword arguments from AST argument nodes.
@@ -75,10 +77,22 @@ pub(crate) enum DispatchResult {
 
 /// Kind of child processing needed
 pub(crate) enum NeedsChildKind<'a> {
-    /// Instance variable write: need to process value, then call finish_ivar_write
+    /// Instance variable write: need to process value, then call install_ivar_write
     IvarWrite { ivar_name: String, value: Node<'a> },
-    /// Local variable write: need to process value, then call finish_local_var_write
+    /// Class variable write: need to process value, then call install_class_var_write
+    ClassVarWrite { cvar_name: String, value: Node<'a> },
+    /// Local variable write: need to process value, then call install_local_var_write
     LocalVarWrite { var_name: String, value: Node<'a> },
+    /// Global variable write: need to process value, then call install_global_var_write
+    GlobalVarWrite { gvar_name: String, value: Node<'a> },
+    ConstantWrite { const_name: String, value: Node<'a> },
+    CompoundWrite {
+        var_kind: CompoundVarKind,
+        op: CompoundOp,
+        value: Node<'a>,
+    },
+    /// Proc/lambda literals
+    ProcLiteral { block: Node<'a> },
     /// Method call: need to process receiver, then call finish_method_call
     MethodCall {
         receiver: Node<'a>,
@@ -131,6 +145,33 @@ pub(crate) fn dispatch_simple(genv: &mut GlobalEnv, lenv: &mut LocalEnv, node: &
         };
     }
 
+    // Class variable read: @@name
+    // Ruby: uninitialized class variables raise NameError at runtime.
+    // We fall back to nil so downstream method calls are still type-checked
+    // rather than silently skipped. This may produce nil-union types when
+    // reads precede writes in source order.
+    if let Some(cvar_read) = node.as_class_variable_read_node() {
+        let cvar_name = bytes_to_name(cvar_read.name().as_slice());
+        let vtx = install_class_var_read(genv, &cvar_name).unwrap_or_else(|| {
+            let nil_vtx = genv.new_source(Type::Nil);
+            install_class_var_write(genv, cvar_name, nil_vtx)
+        });
+        return DispatchResult::Vertex(vtx);
+    }
+
+    // Global variable read: $name
+    // Ruby: uninitialized global variables are nil.
+    // Register the nil vertex so repeated reads of the same uninitialized
+    // variable reuse one vertex instead of allocating a new Source each time.
+    if let Some(gvar_read) = node.as_global_variable_read_node() {
+        let gvar_name = bytes_to_name(gvar_read.name().as_slice());
+        let vtx = install_global_var_read(genv, &gvar_name).unwrap_or_else(|| {
+            let nil_vtx = genv.new_source(Type::Nil);
+            install_global_var_write(genv, gvar_name, nil_vtx)
+        });
+        return DispatchResult::Vertex(vtx);
+    }
+
     // self
     if node.as_self_node().is_some() {
         return DispatchResult::Vertex(install_self(genv));
@@ -148,6 +189,11 @@ pub(crate) fn dispatch_simple(genv: &mut GlobalEnv, lenv: &mut LocalEnv, node: &
     // ConstantReadNode: User → Type::Singleton("User") or Type::Singleton("Api::User")
     if let Some(const_read) = node.as_constant_read_node() {
         let name = bytes_to_name(const_read.name().as_slice());
+
+        if let Some(vtx) = install_constant_read(genv, &name) {
+            return DispatchResult::Vertex(vtx);
+        }
+
         let resolved_name = genv.scope_manager.lookup_constant(&name)
             .unwrap_or(name);
         let vtx = genv.new_source(Type::singleton(&resolved_name));
@@ -162,6 +208,16 @@ pub(crate) fn dispatch_simple(genv: &mut GlobalEnv, lenv: &mut LocalEnv, node: &
         }
     }
 
+    // defined?(expr) → String | nil (child expression is NOT evaluated)
+    if node.as_defined_node().is_some() {
+        let result_vtx = genv.new_vertex();
+        let str_vtx = genv.new_source(Type::string());
+        let nil_vtx = genv.new_source(Type::Nil);
+        genv.add_edge(str_vtx, result_vtx);
+        genv.add_edge(nil_vtx, result_vtx);
+        return DispatchResult::Vertex(result_vtx);
+    }
+
     DispatchResult::NotHandled
 }
 
@@ -206,6 +262,32 @@ pub(crate) fn dispatch_needs_child<'a>(node: &Node<'a>, source: &str) -> Option<
         });
     }
 
+    // Class variable write: @@name = value
+    if let Some(cvar_write) = node.as_class_variable_write_node() {
+        let cvar_name = bytes_to_name(cvar_write.name().as_slice());
+        return Some(NeedsChildKind::ClassVarWrite {
+            cvar_name,
+            value: cvar_write.value(),
+        });
+    }
+
+    // Global variable write: $name = value
+    if let Some(gvar_write) = node.as_global_variable_write_node() {
+        let gvar_name = bytes_to_name(gvar_write.name().as_slice());
+        return Some(NeedsChildKind::GlobalVarWrite {
+            gvar_name,
+            value: gvar_write.value(),
+        });
+    }
+
+    if let Some(const_write) = node.as_constant_write_node() {
+        let const_name = bytes_to_name(const_write.name().as_slice());
+        return Some(NeedsChildKind::ConstantWrite {
+            const_name,
+            value: const_write.value(),
+        });
+    }
+
     // Local variable write: x = value
     if let Some(write_node) = node.as_local_variable_write_node() {
         let var_name = bytes_to_name(write_node.name().as_slice());
@@ -215,6 +297,46 @@ pub(crate) fn dispatch_needs_child<'a>(node: &Node<'a>, source: &str) -> Option<
         });
     }
 
+    macro_rules! dispatch_compound {
+        ($node:expr, $as_method:ident, $var_kind:ident, operator) => {
+            if let Some(n) = $node.$as_method() {
+                return Some(NeedsChildKind::CompoundWrite {
+                    var_kind: CompoundVarKind::$var_kind(bytes_to_name(n.name().as_slice())),
+                    op: CompoundOp::Operator(bytes_to_name(n.binary_operator().as_slice())),
+                    value: n.value(),
+                });
+            }
+        };
+        ($node:expr, $as_method:ident, $var_kind:ident, $op:ident) => {
+            if let Some(n) = $node.$as_method() {
+                return Some(NeedsChildKind::CompoundWrite {
+                    var_kind: CompoundVarKind::$var_kind(bytes_to_name(n.name().as_slice())),
+                    op: CompoundOp::$op,
+                    value: n.value(),
+                });
+            }
+        };
+    }
+
+    macro_rules! dispatch_compound_all {
+        ($node:expr, $op_method:ident, $or_method:ident, $and_method:ident, $var_kind:ident) => {
+            dispatch_compound!($node, $op_method, $var_kind, operator);
+            dispatch_compound!($node, $or_method, $var_kind, Logical);
+            dispatch_compound!($node, $and_method, $var_kind, Logical);
+        };
+    }
+
+    dispatch_compound_all!(node,
+        as_local_variable_operator_write_node, as_local_variable_or_write_node, as_local_variable_and_write_node, Local);
+    dispatch_compound_all!(node,
+        as_instance_variable_operator_write_node, as_instance_variable_or_write_node, as_instance_variable_and_write_node, Ivar);
+    dispatch_compound_all!(node,
+        as_class_variable_operator_write_node, as_class_variable_or_write_node, as_class_variable_and_write_node, ClassVar);
+    dispatch_compound_all!(node,
+        as_global_variable_operator_write_node, as_global_variable_or_write_node, as_global_variable_and_write_node, GlobalVar);
+    dispatch_compound_all!(node,
+        as_constant_operator_write_node, as_constant_or_write_node, as_constant_and_write_node, Constant);
+
     // Method call: x.upcase, x.each { |i| ... }, or name (implicit self)
     if let Some(call_node) = node.as_call_node() {
         let method_name = bytes_to_name(call_node.name().as_slice());
@@ -225,6 +347,16 @@ pub(crate) fn dispatch_needs_child<'a>(node: &Node<'a>, source: &str) -> Option<
             .unwrap_or_default();
 
         if let Some(receiver) = call_node.receiver() {
+            if method_name == "new" {
+                if let Some(const_read) = receiver.as_constant_read_node() {
+                    if const_read.name().as_slice() == b"Proc" {
+                        if let Some(block_node) = block {
+                            return Some(NeedsChildKind::ProcLiteral { block: block_node });
+                        }
+                    }
+                }
+            }
+
             // Explicit receiver: x.upcase, x.each { |i| ... }
             let prism_location = call_node
                 .call_operator_loc()
@@ -243,6 +375,12 @@ pub(crate) fn dispatch_needs_child<'a>(node: &Node<'a>, source: &str) -> Option<
         } else {
             // No receiver: implicit self method call (e.g., `name`, `puts "hello"`)
 
+            if matches!(method_name.as_str(), "lambda" | "proc") {
+                if let Some(block_node) = block {
+                    return Some(NeedsChildKind::ProcLiteral { block: block_node });
+                }
+            }
+
             if let Some(kind) = match method_name.as_str() {
                 "attr_reader" => Some(AttrKind::Reader),
                 "attr_writer" => Some(AttrKind::Writer),
@@ -303,11 +441,36 @@ pub(crate) fn process_needs_child(
     match kind {
         NeedsChildKind::IvarWrite { ivar_name, value } => {
             let value_vtx = super::install::install_node(genv, lenv, changes, source, &value)?;
-            Some(finish_ivar_write(genv, ivar_name, value_vtx))
+            Some(install_ivar_write(genv, ivar_name, value_vtx))
+        }
+        NeedsChildKind::ClassVarWrite { cvar_name, value } => {
+            let value_vtx = super::install::install_node(genv, lenv, changes, source, &value)?;
+            Some(install_class_var_write(genv, cvar_name, value_vtx))
+        }
+        NeedsChildKind::GlobalVarWrite { gvar_name, value } => {
+            let value_vtx = super::install::install_node(genv, lenv, changes, source, &value)?;
+            Some(install_global_var_write(genv, gvar_name, value_vtx))
+        }
+        NeedsChildKind::ConstantWrite { const_name, value } => {
+            let value_vtx = super::install::install_node(genv, lenv, changes, source, &value)?;
+            Some(install_constant_write(genv, const_name, value_vtx))
         }
         NeedsChildKind::LocalVarWrite { var_name, value } => {
             let value_vtx = super::install::install_node(genv, lenv, changes, source, &value)?;
-            Some(finish_local_var_write(genv, lenv, changes, var_name, value_vtx))
+            Some(install_local_var_write(genv, lenv, changes, var_name, value_vtx))
+        }
+        NeedsChildKind::CompoundWrite { var_kind, op, value } => {
+            let value_vtx = super::install::install_node(genv, lenv, changes, source, &value)?;
+            Some(super::compound_assignments::process_compound_write(
+                genv, lenv, changes, var_kind, op, value_vtx,
+            ))
+        }
+        NeedsChildKind::ProcLiteral { block } => {
+            if let Some(block_node) = block.as_block_node() {
+                super::lambdas::process_block_as_proc(genv, lenv, changes, source, &block_node)
+            } else {
+                None
+            }
         }
         NeedsChildKind::MethodCall {
             receiver,
@@ -361,22 +524,6 @@ pub(crate) fn process_needs_child(
     }
 }
 
-/// Finish instance variable write after child is processed
-fn finish_ivar_write(genv: &mut GlobalEnv, ivar_name: String, value_vtx: VertexId) -> VertexId {
-    install_ivar_write(genv, ivar_name, value_vtx)
-}
-
-/// Finish local variable write after child is processed
-fn finish_local_var_write(
-    genv: &mut GlobalEnv,
-    lenv: &mut LocalEnv,
-    changes: &mut ChangeSet,
-    var_name: String,
-    value_vtx: VertexId,
-) -> VertexId {
-    install_local_var_write(genv, lenv, changes, var_name, value_vtx)
-}
-
 /// Bundled parameters for method call processing
 struct MethodCallContext<'a> {
     recv_vtx: VertexId,
@@ -453,3 +600,68 @@ fn finish_method_call(
 ) -> VertexId {
     install_method_call(genv, recv_vtx, method_name, arg_vtxs, kwarg_vtxs, Some(location), safe_navigation)
 }
+
+#[cfg(test)]
+mod tests {
+    use crate::analyzer::AstInstaller;
+    use crate::env::{GlobalEnv, LocalEnv};
+    use crate::parser::ParseSession;
+    use crate::types::Type;
+
+    fn parse_and_install(source: &str) -> GlobalEnv {
+        parse_and_install_with(source, |_| {})
+    }
+
+    fn parse_and_install_with_builtin(source: &str) -> GlobalEnv {
+        parse_and_install_with(source, |genv| {
+            genv.register_builtin_method(Type::string(), "upcase", Type::string());
+        })
+    }
+
+    fn parse_and_install_with(source: &str, setup: impl FnOnce(&mut GlobalEnv)) -> GlobalEnv {
+        let session = ParseSession::new();
+        let result = session.parse_source(source, "<test>").unwrap();
+        let mut genv = GlobalEnv::new();
+        setup(&mut genv);
+        let mut lenv = LocalEnv::new();
+        let mut installer = AstInstaller::new(&mut genv, &mut lenv, source);
+
+        let root = 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();
+        genv
+    }
+
+    #[test]
+    fn test_defined_no_error() {
+        let genv = parse_and_install("result = defined?(foo)");
+        assert!(genv.type_errors.is_empty());
+    }
+
+    #[test]
+    fn test_defined_result_is_string_or_nil() {
+        // Calling upcase on String | nil produces an error for the nil branch
+        let genv = parse_and_install_with_builtin(
+            "result = defined?(foo)\nresult.upcase",
+        );
+        assert!(
+            !genv.type_errors.is_empty(),
+            "defined? returns String | nil, so upcase should error on nil branch"
+        );
+    }
+
+    #[test]
+    fn test_defined_child_not_evaluated() {
+        // If child expression were evaluated, 42.upcase would produce a type error
+        let genv = parse_and_install_with_builtin("defined?(42.upcase)");
+        assert!(
+            genv.type_errors.is_empty(),
+            "Child expression of defined? should not be evaluated"
+        );
+    }
+}

data/core/src/analyzer/install.rs

@@ -10,9 +10,10 @@ use ruby_prism::Node;
 
 use super::assignments::process_multi_write_node;
 use super::blocks::process_block_node;
-use super::conditionals::{process_case_node, process_if_node, process_unless_node};
+use super::conditionals::{process_case_match_node, process_case_node, process_if_node, process_unless_node};
 use super::definitions::{process_class_node, process_def_node, process_module_node};
 use super::exceptions::{process_begin_node, process_rescue_modifier_node};
+use super::lambdas::process_lambda_node;
 use super::dispatch::{dispatch_needs_child, dispatch_simple, process_needs_child, DispatchResult};
 use super::literals::install_literal_node;
 use super::loops::{process_for_node, process_until_node, process_while_node};
@@ -20,6 +21,7 @@ use super::operators::{process_and_node, process_or_node};
 use super::parentheses::process_parentheses_node;
 use super::returns::process_return_node;
 use super::super_calls;
+use super::yields::process_yield_node;
 
 /// Build graph from AST (public API wrapper)
 pub struct AstInstaller<'a> {
@@ -73,6 +75,10 @@ pub(crate) fn install_node(
         return process_block_node(genv, lenv, changes, source, &block_node);
     }
 
+    if let Some(lambda_node) = node.as_lambda_node() {
+        return process_lambda_node(genv, lenv, changes, source, &lambda_node);
+    }
+
     if let Some(if_node) = node.as_if_node() {
         return process_if_node(genv, lenv, changes, source, &if_node);
     }
@@ -82,6 +88,9 @@ pub(crate) fn install_node(
     if let Some(case_node) = node.as_case_node() {
         return process_case_node(genv, lenv, changes, source, &case_node);
     }
+    if let Some(case_match_node) = node.as_case_match_node() {
+        return process_case_match_node(genv, lenv, changes, source, &case_match_node);
+    }
 
     if let Some(begin_node) = node.as_begin_node() {
         return process_begin_node(genv, lenv, changes, source, &begin_node);
@@ -119,6 +128,32 @@ pub(crate) fn install_node(
         return process_return_node(genv, lenv, changes, source, &return_node);
     }
 
+    if let Some(yield_node) = node.as_yield_node() {
+        return process_yield_node(genv, lenv, changes, source, &yield_node);
+    }
+
+    if let Some(next_node) = node.as_next_node() {
+        if let Some(args) = next_node.arguments() {
+            for arg in args.arguments().iter() {
+                install_node(genv, lenv, changes, source, &arg);
+            }
+        }
+        return None;
+    }
+
+    if let Some(break_node) = node.as_break_node() {
+        if let Some(args) = break_node.arguments() {
+            for arg in args.arguments().iter() {
+                install_node(genv, lenv, changes, source, &arg);
+            }
+        }
+        return None;
+    }
+
+    if node.as_redo_node().is_some() || node.as_retry_node().is_some() {
+        return None;
+    }
+
     if let Some(and_node) = node.as_and_node() {
         return process_and_node(genv, lenv, changes, source, &and_node);
     }

data/core/src/analyzer/lambdas.rs

@@ -0,0 +1,153 @@
+//! Lambdas/Procs - type inference for lambda and proc literals
+//!
+//! Handles `-> { }`, `lambda { }`, `proc { }`, and `Proc.new { }`.
+
+use ruby_prism::{LambdaNode, Node};
+
+use crate::env::{GlobalEnv, LocalEnv};
+use crate::graph::{ChangeSet, VertexId};
+use crate::types::Type;
+
+pub(crate) fn process_lambda_node(
+    genv: &mut GlobalEnv,
+    lenv: &mut LocalEnv,
+    changes: &mut ChangeSet,
+    source: &str,
+    lambda_node: &LambdaNode,
+) -> Option<VertexId> {
+    process_proc_body(genv, lenv, changes, source, lambda_node.parameters(), lambda_node.body())
+}
+
+pub(crate) fn process_block_as_proc(
+    genv: &mut GlobalEnv,
+    lenv: &mut LocalEnv,
+    changes: &mut ChangeSet,
+    source: &str,
+    block_node: &ruby_prism::BlockNode,
+) -> Option<VertexId> {
+    process_proc_body(genv, lenv, changes, source, block_node.parameters(), block_node.body())
+}
+
+fn process_proc_body<'a>(
+    genv: &mut GlobalEnv,
+    lenv: &mut LocalEnv,
+    changes: &mut ChangeSet,
+    source: &str,
+    parameters: Option<Node<'a>>,
+    body: Option<Node<'a>>,
+) -> Option<VertexId> {
+    let (_scope_id, merge_vtx) = genv.enter_lambda();
+
+    let param_vtxs = parameters
+        .and_then(|p| p.as_block_parameters_node())
+        .map(|bp| {
+            super::blocks::install_block_parameters_with_vtxs(genv, lenv, changes, source, &bp)
+        })
+        .unwrap_or_default();
+
+    let body_vtx = body.and_then(|b| {
+        if let Some(stmts) = b.as_statements_node() {
+            super::install::install_statements(genv, lenv, changes, source, &stmts)
+        } else {
+            super::install::install_node(genv, lenv, changes, source, &b)
+        }
+    });
+
+    if let Some(vtx) = body_vtx {
+        genv.add_edge(vtx, merge_vtx);
+    }
+
+    genv.exit_scope();
+
+    let proc_ty = Type::proc_type_with_vertex(merge_vtx, param_vtxs);
+    let proc_vtx = genv.new_source(proc_ty);
+
+    Some(proc_vtx)
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::analyzer::AstInstaller;
+    use crate::env::{GlobalEnv, LocalEnv};
+    use crate::parser::ParseSession;
+    use crate::types::Type;
+
+    fn parse_and_install(source: &str) -> GlobalEnv {
+        parse_and_install_with(source, |_| {})
+    }
+
+    fn parse_and_install_with_builtin(source: &str) -> GlobalEnv {
+        parse_and_install_with(source, |genv| {
+            genv.register_builtin_method(Type::string(), "upcase", Type::string());
+        })
+    }
+
+    fn parse_and_install_with(source: &str, setup: impl FnOnce(&mut GlobalEnv)) -> GlobalEnv {
+        let session = ParseSession::new();
+        let result = session.parse_source(source, "<test>").unwrap();
+        let mut genv = GlobalEnv::new();
+        setup(&mut genv);
+        let mut lenv = LocalEnv::new();
+        let mut installer = AstInstaller::new(&mut genv, &mut lenv, source);
+
+        let root = 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();
+        genv
+    }
+
+    #[test]
+    fn test_lambda_basic_no_crash() {
+        let genv = parse_and_install("f = -> { 42 }");
+        assert!(genv.type_errors.is_empty());
+    }
+
+    #[test]
+    fn test_lambda_with_params_no_crash() {
+        let genv = parse_and_install("f = -> (x) { x }");
+        assert!(genv.type_errors.is_empty());
+    }
+
+    #[test]
+    fn test_lambda_body_type_error_detected() {
+        let genv = parse_and_install_with_builtin("f = -> { 42.upcase }");
+        assert!(
+            !genv.type_errors.is_empty(),
+            "Expected type error for 42.upcase inside lambda"
+        );
+    }
+
+    #[test]
+    fn test_lambda_method_basic() {
+        let genv = parse_and_install("f = lambda { 42 }");
+        assert!(genv.type_errors.is_empty());
+    }
+
+    #[test]
+    fn test_proc_method_basic() {
+        let genv = parse_and_install("f = proc { 42 }");
+        assert!(genv.type_errors.is_empty());
+    }
+
+    #[test]
+    fn test_proc_new_basic() {
+        let genv = parse_and_install("f = Proc.new { 42 }");
+        assert!(genv.type_errors.is_empty());
+    }
+
+    #[test]
+    fn test_lambda_call_arg_type_propagation() {
+        let genv = parse_and_install_with_builtin(
+            "f = ->(x) { x.upcase }\nf.call(42)",
+        );
+        assert!(
+            !genv.type_errors.is_empty(),
+            "Expected type error for 42.upcase via lambda arg propagation"
+        );
+    }
+}

data/core/src/analyzer/literals.rs

@@ -58,6 +58,14 @@ pub(crate) fn install_literal_node(
         return Some(genv.new_source(Type::regexp()));
     }
 
+    // InterpolatedXStringNode: `command #{expr}` → String
+    if let Some(interp) = node.as_interpolated_x_string_node() {
+        for part in &interp.parts() {
+            super::install::install_node(genv, lenv, changes, source, &part);
+        }
+        return Some(genv.new_source(Type::string()));
+    }
+
     install_simple_literal(genv, node)
 }
 
@@ -87,6 +95,9 @@ fn install_simple_literal(genv: &mut GlobalEnv, node: &Node) -> Option<VertexId>
     if node.as_regular_expression_node().is_some() {
         return Some(genv.new_source(Type::regexp()));
     }
+    if node.as_x_string_node().is_some() {
+        return Some(genv.new_source(Type::string()));
+    }
     None
 }
 

data/core/src/analyzer/mod.rs

@@ -2,11 +2,13 @@ mod assignments;
 mod attributes;
 mod blocks;
 mod calls;
+mod compound_assignments;
 mod conditionals;
 mod definitions;
 mod exceptions;
 mod dispatch;
 mod install;
+mod lambdas;
 mod literals;
 mod loops;
 mod operators;
@@ -15,6 +17,7 @@ mod parentheses;
 mod returns;
 mod super_calls;
 mod variables;
+mod yields;
 
 pub use install::AstInstaller;