method-ray 0.1.10 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 228f256ea9848bd9b2447e097aee95f59f47db2bd252611a7dfa30363be34a23
-  data.tar.gz: 0ff2217ee68021004331bd580f26739ce067f223ea113b741ab0636f2771e30e
+  metadata.gz: 23dc6a87888386dca19ac6c02c051df5712943cffd755ed29437117273347f51
+  data.tar.gz: ba211cf132132316f6efa5fbfa5061df93ba9b81b0766192e85a25273720efd8
 SHA512:
-  metadata.gz: 3c274c68e498eed4f432b60c4a68a6ca469b7850db539954f584d89bd96cbf3612e03a9a9f43a1b8a8941be6302142e7f34e886b279cde41bc22a0376ba48ac7
-  data.tar.gz: 57e66add8decf8c951f890f140f76fca86b642af91a7df9d7622c5144414b20f158444838aeca5082a46efa185280747a32117980654ae5f03d0c1dc23bbcd35
+  metadata.gz: f485df1d4c80d86bdaa60e4ffb968fc919669e7df4142a91093a2b4004ce758112aeb701936f1e96b2a2a933724c7a38eb9cae982ae55994b664ac604f2c19e8
+  data.tar.gz: ad0ab16ba07f4966ff06acde966527bfcac0a96e1a6b65563f5a82dc1454e541ed3c74a35fc8c950a15f662abe2ac00fb66809296c2b4761a9cc523ba3db71de

data/CHANGELOG.md

@@ -5,6 +5,27 @@ 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.2.0] - 2026-04-05
+
+### Added
+
+- Add pattern matching type inference ([#103](https://github.com/dak2/method-ray/pull/103))
+- Add Lambda/Proc type inference support ([#104](https://github.com/dak2/method-ray/pull/104))
+- Add compound assignment type inference ([#105](https://github.com/dak2/method-ray/pull/105))
+- Add `defined?` type inference support ([#106](https://github.com/dak2/method-ray/pull/106))
+- Add `yield` type inference support ([#107](https://github.com/dak2/method-ray/pull/107))
+- Add control flow keyword support (`break`, `next`, `retry`, `redo`) ([#108](https://github.com/dak2/method-ray/pull/108))
+- Add backtick string type inference ([#109](https://github.com/dak2/method-ray/pull/109))
+- Add predicate type propagation to pattern variables in `case...in` ([#110](https://github.com/dak2/method-ray/pull/110))
+- Add constant type inference support ([#102](https://github.com/dak2/method-ray/pull/102))
+- Add global variable (`$var`) type tracking ([#100](https://github.com/dak2/method-ray/pull/100))
+- Add class variable (`@@var`) type tracking ([#99](https://github.com/dak2/method-ray/pull/99))
+
+### Fixed
+
+- Fix uninitialized `@@var` reads silently skipping downstream type checking ([#101](https://github.com/dak2/method-ray/pull/101))
+- Fix release workflow not triggered after tag push ([#88](https://github.com/dak2/method-ray/pull/88))
+
 ## [0.1.10] - 2026-03-24
 
 ### Added
@@ -159,6 +180,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.2.0]: https://github.com/dak2/method-ray/releases/tag/v0.2.0
 [0.1.10]: https://github.com/dak2/method-ray/releases/tag/v0.1.10
 [0.1.9]: https://github.com/dak2/method-ray/releases/tag/v0.1.9
 [0.1.8]: https://github.com/dak2/method-ray/releases/tag/v0.1.8

data/core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "methodray-core"
-version = "0.1.10"
+version = "0.2.0"
 edition = "2021"
 
 [lib]

data/core/src/analyzer/blocks.rs

@@ -56,7 +56,7 @@ pub(crate) fn process_block_node_with_params(
 }
 
 /// Install block parameters and return their vertex IDs
-fn install_block_parameters_with_vtxs(
+pub(crate) fn install_block_parameters_with_vtxs(
     genv: &mut GlobalEnv,
     lenv: &mut LocalEnv,
     changes: &mut ChangeSet,

data/core/src/analyzer/compound_assignments.rs

@@ -0,0 +1,194 @@
+//! Compound assignment handlers (`x += 1`, `x ||= val`, `x &&= val`).
+//!
+//! `||=` and `&&=` use the same Union(existing, val) approximation — a sound
+//! over-approximation without condition narrowing.
+
+use crate::env::{GlobalEnv, LocalEnv};
+use crate::graph::{ChangeSet, VertexId};
+use crate::types::Type;
+
+use super::calls::install_method_call;
+use super::variables::{
+    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,
+};
+
+pub(crate) enum CompoundVarKind {
+    Local(String),
+    Ivar(String),
+    ClassVar(String),
+    GlobalVar(String),
+    Constant(String),
+}
+
+impl CompoundVarKind {
+    fn read(&self, genv: &GlobalEnv, lenv: &LocalEnv) -> Option<VertexId> {
+        match self {
+            Self::Local(name) => install_local_var_read(lenv, name),
+            Self::Ivar(name) => install_ivar_read(genv, name),
+            Self::ClassVar(name) => install_class_var_read(genv, name),
+            Self::GlobalVar(name) => install_global_var_read(genv, name),
+            Self::Constant(name) => install_constant_read(genv, name),
+        }
+    }
+
+    fn write(
+        self,
+        genv: &mut GlobalEnv,
+        lenv: &mut LocalEnv,
+        changes: &mut ChangeSet,
+        value_vtx: VertexId,
+    ) -> VertexId {
+        match self {
+            Self::Local(name) => install_local_var_write(genv, lenv, changes, name, value_vtx),
+            Self::Ivar(name) => install_ivar_write(genv, name, value_vtx),
+            Self::ClassVar(name) => install_class_var_write(genv, name, value_vtx),
+            Self::GlobalVar(name) => install_global_var_write(genv, name, value_vtx),
+            Self::Constant(name) => install_constant_write(genv, name, value_vtx),
+        }
+    }
+}
+
+pub(crate) enum CompoundOp {
+    Operator(String),
+    Logical,
+}
+
+pub(crate) fn process_compound_write(
+    genv: &mut GlobalEnv,
+    lenv: &mut LocalEnv,
+    changes: &mut ChangeSet,
+    var_kind: CompoundVarKind,
+    op: CompoundOp,
+    value_vtx: VertexId,
+) -> VertexId {
+    match op {
+        CompoundOp::Operator(operator) => {
+            let current_vtx = var_kind.read(genv, lenv)
+                .unwrap_or_else(|| genv.new_source(Type::Nil));
+            let result_vtx = install_method_call(
+                genv, current_vtx, operator, vec![value_vtx], None, None, false,
+            );
+            var_kind.write(genv, lenv, changes, result_vtx)
+        }
+        CompoundOp::Logical => {
+            let merge_vtx = genv.new_vertex();
+            if let Some(current_vtx) = var_kind.read(genv, lenv) {
+                genv.add_edge(current_vtx, merge_vtx);
+            }
+            genv.add_edge(value_vtx, merge_vtx);
+            var_kind.write(genv, lenv, changes, merge_vtx)
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_operator_write() {
+        let mut genv = GlobalEnv::new();
+        let mut lenv = LocalEnv::new();
+        let mut changes = ChangeSet::new();
+
+        let int_vtx = genv.new_source(Type::integer());
+        install_local_var_write(&mut genv, &mut lenv, &mut changes, "x".to_string(), int_vtx);
+
+        let rhs_vtx = genv.new_source(Type::integer());
+        let result = process_compound_write(
+            &mut genv, &mut lenv, &mut changes,
+            CompoundVarKind::Local("x".to_string()),
+            CompoundOp::Operator("+".to_string()),
+            rhs_vtx,
+        );
+
+        assert_ne!(result, int_vtx);
+        assert_eq!(install_local_var_read(&lenv, "x"), Some(result));
+    }
+
+    #[test]
+    fn test_operator_write_uninitialized() {
+        let mut genv = GlobalEnv::new();
+        let mut lenv = LocalEnv::new();
+        let mut changes = ChangeSet::new();
+
+        let rhs_vtx = genv.new_source(Type::integer());
+        let result = process_compound_write(
+            &mut genv, &mut lenv, &mut changes,
+            CompoundVarKind::Local("x".to_string()),
+            CompoundOp::Operator("+".to_string()),
+            rhs_vtx,
+        );
+
+        assert_eq!(install_local_var_read(&lenv, "x"), Some(result));
+    }
+
+    #[test]
+    fn test_logical_write_produces_union() {
+        let mut genv = GlobalEnv::new();
+        let mut lenv = LocalEnv::new();
+        let mut changes = ChangeSet::new();
+
+        let str_vtx = genv.new_source(Type::string());
+        install_local_var_write(&mut genv, &mut lenv, &mut changes, "x".to_string(), str_vtx);
+
+        let int_vtx = genv.new_source(Type::integer());
+        let result = process_compound_write(
+            &mut genv, &mut lenv, &mut changes,
+            CompoundVarKind::Local("x".to_string()),
+            CompoundOp::Logical,
+            int_vtx,
+        );
+
+        assert_eq!(install_local_var_read(&lenv, "x"), Some(result));
+        genv.apply_changes(changes);
+        genv.run_all();
+        let types = genv.get_receiver_types(result).unwrap();
+        assert!(types.contains(&Type::string()));
+        assert!(types.contains(&Type::integer()));
+    }
+
+    #[test]
+    fn test_logical_write_uninitialized() {
+        let mut genv = GlobalEnv::new();
+        let mut lenv = LocalEnv::new();
+        let mut changes = ChangeSet::new();
+
+        let str_vtx = genv.new_source(Type::string());
+        let result = process_compound_write(
+            &mut genv, &mut lenv, &mut changes,
+            CompoundVarKind::Local("x".to_string()),
+            CompoundOp::Logical,
+            str_vtx,
+        );
+
+        genv.apply_changes(changes);
+        genv.run_all();
+        let types = genv.get_receiver_types(result).unwrap();
+        assert!(types.contains(&Type::string()));
+    }
+
+    #[test]
+    fn test_ivar_compound_write() {
+        let mut genv = GlobalEnv::new();
+        let mut lenv = LocalEnv::new();
+        let mut changes = ChangeSet::new();
+        genv.enter_class("TestClass".to_string(), None);
+        genv.enter_method("test_method".to_string());
+
+        let int_vtx = genv.new_source(Type::integer());
+        install_ivar_write(&mut genv, "@count".to_string(), int_vtx);
+
+        let rhs_vtx = genv.new_source(Type::integer());
+        let result = process_compound_write(
+            &mut genv, &mut lenv, &mut changes,
+            CompoundVarKind::Ivar("@count".to_string()),
+            CompoundOp::Operator("+".to_string()),
+            rhs_vtx,
+        );
+
+        assert_eq!(result, int_vtx);
+    }
+}

data/core/src/analyzer/conditionals.rs

@@ -1,4 +1,4 @@
-//! Conditionals - if/unless/case type inference
+ //! Conditionals - if/unless/case type inference
 //!
 //! Collects types from each branch and merges them into a Union
 //! via edges into a single result Vertex.
@@ -6,9 +6,14 @@
 use crate::env::{GlobalEnv, LocalEnv};
 use crate::graph::{ChangeSet, VertexId};
 use crate::types::Type;
-use ruby_prism::{CaseNode, ElseNode, IfNode, Node, UnlessNode, WhenNode};
+use ruby_prism::{
+    ArrayPatternNode, CapturePatternNode, CaseMatchNode, CaseNode, ElseNode, FindPatternNode,
+    HashPatternNode, IfNode, InNode, Node, UnlessNode, WhenNode,
+};
 
+use super::bytes_to_name;
 use super::install::{install_node, install_statements};
+use super::variables::install_local_var_write;
 
 /// Process IfNode: if/elsif/else chain
 pub(crate) fn process_if_node(
@@ -137,6 +142,47 @@ pub(crate) fn process_case_node(
     Some(result_vtx)
 }
 
+/// Process CaseMatchNode: case/in pattern matching
+pub(crate) fn process_case_match_node(
+    genv: &mut GlobalEnv,
+    lenv: &mut LocalEnv,
+    changes: &mut ChangeSet,
+    source: &str,
+    node: &CaseMatchNode,
+) -> Option<VertexId> {
+    let predicate_vtx = node
+        .predicate()
+        .and_then(|pred| install_node(genv, lenv, changes, source, &pred));
+
+    let result_vtx = genv.new_vertex();
+
+    for condition in &node.conditions() {
+        if let Some(in_node) = condition.as_in_node() {
+            let vtx = process_in_clause(genv, lenv, changes, source, &in_node, predicate_vtx);
+            if let Some(vtx) = vtx {
+                genv.add_edge(vtx, result_vtx);
+            }
+        }
+    }
+
+    let has_else = if let Some(else_node) = node.else_clause() {
+        let vtx = process_else_clause(genv, lenv, changes, source, &else_node);
+        if let Some(vtx) = vtx {
+            genv.add_edge(vtx, result_vtx);
+        }
+        true
+    } else {
+        false
+    };
+
+    if !has_else {
+        let nil_vtx = genv.new_source(Type::Nil);
+        genv.add_edge(nil_vtx, result_vtx);
+    }
+
+    Some(result_vtx)
+}
+
 /// Process subsequent node (elsif chain or else)
 fn process_subsequent(
     genv: &mut GlobalEnv,
@@ -188,3 +234,223 @@ fn process_when_clause(
         .statements()
         .and_then(|stmts| install_statements(genv, lenv, changes, source, &stmts))
 }
+
+/// Process InNode clause body
+fn process_in_clause(
+    genv: &mut GlobalEnv,
+    lenv: &mut LocalEnv,
+    changes: &mut ChangeSet,
+    source: &str,
+    in_node: &InNode,
+    predicate_vtx: Option<VertexId>,
+) -> Option<VertexId> {
+    process_pattern(genv, lenv, changes, source, &in_node.pattern(), predicate_vtx);
+    in_node
+        .statements()
+        .and_then(|s| install_statements(genv, lenv, changes, source, &s))
+}
+
+/// Dispatch pattern processing based on pattern type
+fn process_pattern(
+    genv: &mut GlobalEnv,
+    lenv: &mut LocalEnv,
+    changes: &mut ChangeSet,
+    source: &str,
+    pattern: &Node,
+    predicate_vtx: Option<VertexId>,
+) {
+    // Guard pattern (in x if condition)
+    if let Some(if_node) = pattern.as_if_node() {
+        if let Some(stmts) = if_node.statements() {
+            for stmt in &stmts.body() {
+                process_pattern(genv, lenv, changes, source, &stmt, predicate_vtx);
+            }
+        }
+        install_node(genv, lenv, changes, source, &if_node.predicate());
+        return;
+    }
+
+    if let Some(cap) = pattern.as_capture_pattern_node() {
+        process_capture_pattern(genv, lenv, changes, source, &cap);
+        return;
+    }
+
+    // ImplicitNode: hash shorthand pattern { name: } wraps LocalVariableTargetNode
+    if let Some(implicit) = pattern.as_implicit_node() {
+        process_pattern(genv, lenv, changes, source, &implicit.value(), predicate_vtx);
+        return;
+    }
+
+    // LocalVariableTargetNode: single variable binding (in x)
+    if let Some(target) = pattern.as_local_variable_target_node() {
+        let var_name = bytes_to_name(target.name().as_slice());
+        let type_vtx = predicate_vtx.unwrap_or_else(|| genv.new_source(Type::Bot));
+        install_local_var_write(genv, lenv, changes, var_name, type_vtx);
+        return;
+    }
+
+    if let Some(arr) = pattern.as_array_pattern_node() {
+        process_array_pattern(genv, lenv, changes, source, &arr, predicate_vtx);
+        return;
+    }
+
+    if let Some(find) = pattern.as_find_pattern_node() {
+        process_find_pattern(genv, lenv, changes, source, &find, predicate_vtx);
+        return;
+    }
+
+    if let Some(hash) = pattern.as_hash_pattern_node() {
+        process_hash_pattern(genv, lenv, changes, source, &hash, predicate_vtx);
+        return;
+    }
+
+    // AlternationPatternNode: 1 | 2 | 3
+    if let Some(alt) = pattern.as_alternation_pattern_node() {
+        process_pattern(genv, lenv, changes, source, &alt.left(), predicate_vtx);
+        process_pattern(genv, lenv, changes, source, &alt.right(), predicate_vtx);
+        return;
+    }
+
+    // PinnedVariableNode: ^x
+    if let Some(pinned) = pattern.as_pinned_variable_node() {
+        install_node(genv, lenv, changes, source, &pinned.variable());
+        return;
+    }
+
+    // PinnedExpressionNode: ^(expr)
+    if let Some(pinned) = pattern.as_pinned_expression_node() {
+        install_node(genv, lenv, changes, source, &pinned.expression());
+        return;
+    }
+
+    // Literal patterns (Integer, String, etc.) - side effects only
+    install_node(genv, lenv, changes, source, pattern);
+}
+
+/// Process capture pattern: Integer => x, Api::User => u
+fn process_capture_pattern(
+    genv: &mut GlobalEnv,
+    lenv: &mut LocalEnv,
+    changes: &mut ChangeSet,
+    source: &str,
+    cap: &CapturePatternNode,
+) {
+    let value_node = cap.value();
+    let target = cap.target();
+    let var_name = bytes_to_name(target.name().as_slice());
+
+    let type_vtx = if let Some(name) = super::definitions::extract_constant_path(&value_node) {
+        genv.new_source(Type::instance(&name))
+    } else {
+        install_node(genv, lenv, changes, source, &value_node)
+            .unwrap_or_else(|| genv.new_vertex())
+    };
+
+    install_local_var_write(genv, lenv, changes, var_name, type_vtx);
+}
+
+// TODO: Remove clone 
+fn type_arg_source(genv: &mut GlobalEnv, vtx: VertexId, index: usize) -> Option<VertexId> {
+    let source = genv.get_source(vtx)?;
+    let ty = match &source.ty {
+        Type::Generic { type_args, .. } => type_args.get(index)?.clone(),
+        _ => return None,
+    };
+    Some(genv.new_source(ty))
+}
+
+/// Process array pattern: [x, y] or [x, *rest]
+fn process_array_pattern(
+    genv: &mut GlobalEnv,
+    lenv: &mut LocalEnv,
+    changes: &mut ChangeSet,
+    source: &str,
+    arr: &ArrayPatternNode,
+    predicate_vtx: Option<VertexId>,
+) {
+    let element_vtx = predicate_vtx.and_then(|vtx| type_arg_source(genv, vtx, 0));
+
+    for elem in &arr.requireds() {
+        process_pattern(genv, lenv, changes, source, &elem, element_vtx);
+    }
+
+    if let Some(target) = arr
+        .rest()
+        .and_then(|r| r.as_splat_node())
+        .and_then(|s| s.expression())
+        .and_then(|e| e.as_local_variable_target_node())
+    {
+        let var_name = bytes_to_name(target.name().as_slice());
+        let rest_vtx = predicate_vtx.unwrap_or_else(|| genv.new_source(Type::array_of(Type::Bot)));
+        install_local_var_write(genv, lenv, changes, var_name, rest_vtx);
+    }
+
+    for elem in &arr.posts() {
+        process_pattern(genv, lenv, changes, source, &elem, element_vtx);
+    }
+}
+
+/// Process hash pattern: { name:, age: }
+fn process_hash_pattern(
+    genv: &mut GlobalEnv,
+    lenv: &mut LocalEnv,
+    changes: &mut ChangeSet,
+    source: &str,
+    hash: &HashPatternNode,
+    predicate_vtx: Option<VertexId>,
+) {
+    let value_vtx = predicate_vtx.and_then(|vtx| type_arg_source(genv, vtx, 1));
+
+    for elem in &hash.elements() {
+        if let Some(assoc) = elem.as_assoc_node() {
+            process_pattern(genv, lenv, changes, source, &assoc.value(), value_vtx);
+        }
+    }
+
+    if let Some(target) = hash
+        .rest()
+        .and_then(|r| r.as_assoc_splat_node())
+        .and_then(|s| s.value())
+        .and_then(|v| v.as_local_variable_target_node())
+    {
+        let var_name = bytes_to_name(target.name().as_slice());
+        let hash_vtx = genv.new_source(Type::hash());
+        install_local_var_write(genv, lenv, changes, var_name, hash_vtx);
+    }
+}
+
+/// Process find pattern: [*, x, *]
+fn process_find_pattern(
+    genv: &mut GlobalEnv,
+    lenv: &mut LocalEnv,
+    changes: &mut ChangeSet,
+    source: &str,
+    find: &FindPatternNode,
+    predicate_vtx: Option<VertexId>,
+) {
+    let element_vtx = predicate_vtx.and_then(|vtx| type_arg_source(genv, vtx, 0));
+    let rest_vtx = predicate_vtx.unwrap_or_else(|| genv.new_source(Type::array_of(Type::Bot)));
+
+    if let Some(target) = find
+        .left()
+        .expression()
+        .and_then(|e| e.as_local_variable_target_node())
+    {
+        let var_name = bytes_to_name(target.name().as_slice());
+        install_local_var_write(genv, lenv, changes, var_name, rest_vtx);
+    }
+
+    for elem in &find.requireds() {
+        process_pattern(genv, lenv, changes, source, &elem, element_vtx);
+    }
+
+    if let Some(target) = find
+        .right()
+        .as_splat_node()
+        .and_then(|s| s.expression())
+        .and_then(|e| e.as_local_variable_target_node())
+    {
+        let var_name = bytes_to_name(target.name().as_slice());
+        install_local_var_write(genv, lenv, changes, var_name, rest_vtx);
+    }
+}