method-ray 0.1.10 → 0.2.0

data/core/src/analyzer/variables.rs

@@ -3,6 +3,9 @@
 //! This module is responsible for:
 //! - Local variable read/write (x, x = value)
 //! - Instance variable read/write (@name, @name = value)
+//! - Class variable read/write (@@name, @@name = value)
+//! - Global variable read/write ($var, $var = value)
+//! - Constant read/write (CONST = value, CONST)
 //! - self node handling
 
 use crate::env::{GlobalEnv, LocalEnv};
@@ -62,3 +65,224 @@ pub(crate) fn install_self(genv: &mut GlobalEnv) -> VertexId {
         genv.new_source(Type::instance("Object"))
     }
 }
+
+/// Install class variable write: @@name = value
+///
+/// If @@name already has a VertexId (e.g., from a previous assignment),
+/// an edge is added from value_vtx to the existing vertex so types propagate.
+/// Otherwise, value_vtx is registered directly as the cvar's VertexId.
+pub(crate) fn install_class_var_write(
+    genv: &mut GlobalEnv,
+    cvar_name: String,
+    value_vtx: VertexId,
+) -> VertexId {
+    if let Some(existing_vtx) = genv.scope_manager.lookup_class_var(&cvar_name) {
+        genv.add_edge(value_vtx, existing_vtx);
+        existing_vtx
+    } else {
+        genv.scope_manager.set_class_var_in_class(cvar_name, value_vtx);
+        value_vtx
+    }
+}
+
+/// Install class variable read: @@name
+pub(crate) fn install_class_var_read(genv: &GlobalEnv, cvar_name: &str) -> Option<VertexId> {
+    genv.scope_manager.lookup_class_var(cvar_name)
+}
+
+/// Install global variable write: $var = value
+///
+/// Delegates to [`GlobalEnv::set_global_var`] for edge behavior details.
+pub(crate) fn install_global_var_write(
+    genv: &mut GlobalEnv,
+    gvar_name: String,
+    value_vtx: VertexId,
+) -> VertexId {
+    genv.set_global_var(gvar_name, value_vtx)
+}
+
+/// Install global variable read: $var
+pub(crate) fn install_global_var_read(genv: &GlobalEnv, gvar_name: &str) -> Option<VertexId> {
+    genv.get_global_var(gvar_name)
+}
+
+pub(crate) fn install_constant_write(
+    genv: &mut GlobalEnv,
+    const_name: String,
+    value_vtx: VertexId,
+) -> VertexId {
+    let key = match genv.scope_manager.current_qualified_name() {
+        Some(ns) => format!("{}::{}", ns, const_name),
+        None => const_name,
+    };
+    genv.set_constant(key, value_vtx)
+}
+
+pub(crate) fn install_constant_read(
+    genv: &GlobalEnv,
+    const_name: &str,
+) -> Option<VertexId> {
+    if let Some(ns) = genv.scope_manager.current_qualified_name() {
+        let mut current_ns = ns.as_str();
+        loop {
+            let key = format!("{}::{}", current_ns, const_name);
+            if let Some(vtx) = genv.get_constant(&key) {
+                return Some(vtx);
+            }
+            match current_ns.rfind("::") {
+                Some(pos) => current_ns = &current_ns[..pos],
+                None => break,
+            }
+        }
+    }
+    genv.get_constant(const_name)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::types::Type;
+
+    fn setup_class_scope(genv: &mut GlobalEnv) {
+        genv.enter_class("TestClass".to_string(), None);
+        genv.enter_method("test_method".to_string());
+    }
+
+    #[test]
+    fn test_install_class_var_write_new() {
+        let mut genv = GlobalEnv::new();
+        setup_class_scope(&mut genv);
+
+        let value_vtx = genv.new_source(Type::integer());
+        let result_vtx = install_class_var_write(&mut genv, "@@count".to_string(), value_vtx);
+
+        assert_eq!(result_vtx, value_vtx);
+    }
+
+    #[test]
+    fn test_install_class_var_read_after_write() {
+        let mut genv = GlobalEnv::new();
+        setup_class_scope(&mut genv);
+
+        let value_vtx = genv.new_source(Type::integer());
+        install_class_var_write(&mut genv, "@@count".to_string(), value_vtx);
+
+        let read_vtx = install_class_var_read(&genv, "@@count");
+        assert_eq!(read_vtx, Some(value_vtx));
+    }
+
+    #[test]
+    fn test_install_class_var_read_undefined() {
+        let genv = GlobalEnv::new();
+        assert_eq!(install_class_var_read(&genv, "@@undefined"), None);
+    }
+
+    #[test]
+    fn test_install_class_var_write_twice_merges() {
+        let mut genv = GlobalEnv::new();
+        setup_class_scope(&mut genv);
+
+        let str_vtx = genv.new_source(Type::string());
+        let vtx1 = install_class_var_write(&mut genv, "@@var".to_string(), str_vtx);
+
+        let int_vtx = genv.new_source(Type::integer());
+        let vtx2 = install_class_var_write(&mut genv, "@@var".to_string(), int_vtx);
+
+        assert_eq!(vtx1, vtx2);
+    }
+
+    #[test]
+    fn test_global_var_write_and_read() {
+        let mut genv = GlobalEnv::new();
+        let value_vtx = genv.new_source(Type::instance("String"));
+        let result_vtx = install_global_var_write(&mut genv, "$config".to_string(), value_vtx);
+        assert_eq!(result_vtx, value_vtx);
+
+        let read_vtx = install_global_var_read(&genv, "$config");
+        assert_eq!(read_vtx, Some(value_vtx));
+    }
+
+    #[test]
+    fn test_global_var_read_unregistered() {
+        let genv = GlobalEnv::new();
+        let read_vtx = install_global_var_read(&genv, "$unknown");
+        assert_eq!(read_vtx, None);
+    }
+
+    #[test]
+    fn test_global_var_write_twice_returns_same_vertex() {
+        let mut genv = GlobalEnv::new();
+        let vtx1 = genv.new_source(Type::instance("String"));
+        let first = install_global_var_write(&mut genv, "$data".to_string(), vtx1);
+
+        let vtx2 = genv.new_source(Type::instance("Integer"));
+        let second = install_global_var_write(&mut genv, "$data".to_string(), vtx2);
+
+        assert_eq!(first, second);
+        assert_eq!(install_global_var_read(&genv, "$data"), Some(first));
+    }
+
+    #[test]
+    fn test_global_var_write_twice_propagates_via_vertex() {
+        let mut genv = GlobalEnv::new();
+        let var_vtx = genv.new_vertex();
+        install_global_var_write(&mut genv, "$data".to_string(), var_vtx);
+
+        let str_src = genv.new_source(Type::instance("String"));
+        install_global_var_write(&mut genv, "$data".to_string(), str_src);
+
+        let types = genv.get_receiver_types(var_vtx).unwrap();
+        assert!(types.contains(&Type::instance("String")));
+    }
+
+    #[test]
+    fn test_constant_write_twice_merges() {
+        let mut genv = GlobalEnv::new();
+        let str_vtx = genv.new_source(Type::string());
+        let vtx1 = install_constant_write(&mut genv, "VAL".to_string(), str_vtx);
+
+        let int_vtx = genv.new_source(Type::integer());
+        let vtx2 = install_constant_write(&mut genv, "VAL".to_string(), int_vtx);
+
+        assert_eq!(vtx1, vtx2);
+    }
+
+    #[test]
+    fn test_constant_read_undefined() {
+        let genv = GlobalEnv::new();
+        assert_eq!(install_constant_read(&genv, "UNDEFINED"), None);
+    }
+
+    #[test]
+    fn test_constant_read_nested_namespace_walk() {
+        let mut genv = GlobalEnv::new();
+
+        genv.enter_class("Api".to_string(), None);
+        let api_vtx = genv.new_source(Type::string());
+        install_constant_write(&mut genv, "VERSION".to_string(), api_vtx);
+
+        genv.enter_class("V1".to_string(), None);
+        genv.enter_class("Users".to_string(), None);
+        genv.enter_method("index".to_string());
+
+        let read = install_constant_read(&genv, "VERSION");
+        assert_eq!(read, Some(api_vtx));
+    }
+
+    #[test]
+    fn test_constant_read_prefers_inner_namespace() {
+        let mut genv = GlobalEnv::new();
+
+        let top_vtx = genv.new_source(Type::string());
+        install_constant_write(&mut genv, "NAME".to_string(), top_vtx);
+
+        genv.enter_class("Config".to_string(), None);
+        let class_vtx = genv.new_source(Type::integer());
+        install_constant_write(&mut genv, "NAME".to_string(), class_vtx);
+
+        genv.enter_method("get_name".to_string());
+
+        let read = install_constant_read(&genv, "NAME");
+        assert_eq!(read, Some(class_vtx));
+    }
+}

data/core/src/analyzer/yields.rs

@@ -0,0 +1,24 @@
+//! Yield statement handling
+
+use crate::env::{GlobalEnv, LocalEnv};
+use crate::graph::{ChangeSet, VertexId};
+
+use super::install::install_node;
+
+/// Process YieldNode: evaluate arguments for type checking, return unresolved vertex
+pub(crate) fn process_yield_node(
+    genv: &mut GlobalEnv,
+    lenv: &mut LocalEnv,
+    changes: &mut ChangeSet,
+    source: &str,
+    yield_node: &ruby_prism::YieldNode,
+) -> Option<VertexId> {
+    // TODO: Connect argument vertices to block parameter types
+    if let Some(args) = yield_node.arguments() {
+        for arg in args.arguments().iter() {
+            install_node(genv, lenv, changes, source, &arg);
+        }
+    }
+
+    Some(genv.new_vertex())
+}

data/core/src/env/global_env.rs

@@ -46,6 +46,11 @@ pub struct GlobalEnv {
 
     /// Module extensions: class_name → Vec<module_name> (in extend order)
     module_extensions: HashMap<String, Vec<String>>,
+
+    /// Global variables: $var_name → VertexId
+    global_variables: HashMap<String, VertexId>,
+
+    constants: HashMap<String, VertexId>,
 }
 
 impl GlobalEnv {
@@ -59,6 +64,8 @@ impl GlobalEnv {
             module_inclusions: HashMap::new(),
             superclass_map: HashMap::new(),
             module_extensions: HashMap::new(),
+            global_variables: HashMap::new(),
+            constants: HashMap::new(),
         }
     }
 
@@ -234,6 +241,25 @@ impl GlobalEnv {
         );
     }
 
+    // ===== Global Variables =====
+
+    /// Set a global variable. If it already exists, add an edge from value_vtx
+    /// to the existing vertex so types propagate. Otherwise, register value_vtx directly.
+    pub fn set_global_var(&mut self, name: String, value_vtx: VertexId) -> VertexId {
+        if let Some(&existing_vtx) = self.global_variables.get(&name) {
+            self.add_edge(value_vtx, existing_vtx);
+            existing_vtx
+        } else {
+            self.global_variables.insert(name, value_vtx);
+            value_vtx
+        }
+    }
+
+    /// Get the vertex for a global variable, if it has been registered.
+    pub fn get_global_var(&self, name: &str) -> Option<VertexId> {
+        self.global_variables.get(name).copied()
+    }
+
     // ===== Type Errors =====
 
     /// Record a type error (undefined method)
@@ -247,6 +273,20 @@ impl GlobalEnv {
             .push(TypeError::new(receiver_type, method_name, location));
     }
 
+    pub fn set_constant(&mut self, key: String, value_vtx: VertexId) -> VertexId {
+        if let Some(&existing_vtx) = self.constants.get(&key) {
+            self.add_edge(value_vtx, existing_vtx);
+            existing_vtx
+        } else {
+            self.constants.insert(key, value_vtx);
+            value_vtx
+        }
+    }
+
+    pub fn get_constant(&self, key: &str) -> Option<VertexId> {
+        self.constants.get(key).copied()
+    }
+
     // ===== Scope Management =====
 
     /// Register a constant (simple name → qualified name) in the parent scope
@@ -320,6 +360,16 @@ impl GlobalEnv {
         scope_id
     }
 
+    /// Enter a lambda scope
+    pub fn enter_lambda(&mut self) -> (ScopeId, VertexId) {
+        let merge_vtx = self.new_vertex();
+        let scope_id = self.scope_manager.new_scope(ScopeKind::Lambda {
+            return_vertex: Some(merge_vtx),
+        });
+        self.scope_manager.enter_scope(scope_id);
+        (scope_id, merge_vtx)
+    }
+
     /// Exit current scope
     pub fn exit_scope(&mut self) {
         self.scope_manager.exit_scope();

data/core/src/env/scope.rs

@@ -22,6 +22,9 @@ pub enum ScopeKind {
         return_vertex: Option<VertexId>, // Merge vertex for return statements
     },
     Block,
+    Lambda {
+        return_vertex: Option<VertexId>,
+    },
 }
 
 /// Scope information
@@ -76,6 +79,16 @@ impl Scope {
     pub fn get_instance_var(&self, name: &str) -> Option<VertexId> {
         self.instance_vars.get(name).copied()
     }
+
+    /// Add class variable
+    pub fn set_class_var(&mut self, name: String, vtx: VertexId) {
+        self.class_vars.insert(name, vtx);
+    }
+
+    /// Get class variable
+    pub fn get_class_var(&self, name: &str) -> Option<VertexId> {
+        self.class_vars.get(name).copied()
+    }
 }
 
 /// Scope manager
@@ -267,14 +280,12 @@ impl ScopeManager {
         })
     }
 
-    /// Get return_vertex from the nearest enclosing method scope
+    /// Get return_vertex from the nearest enclosing method or lambda scope
     pub fn current_method_return_vertex(&self) -> Option<VertexId> {
-        self.walk_scopes().find_map(|scope| {
-            if let ScopeKind::Method { return_vertex, .. } = &scope.kind {
-                *return_vertex
-            } else {
-                None
-            }
+        self.walk_scopes().find_map(|scope| match &scope.kind {
+            ScopeKind::Method { return_vertex, .. } => *return_vertex,
+            ScopeKind::Lambda { return_vertex } => *return_vertex,
+            _ => None,
         })
     }
 
@@ -296,4 +307,77 @@ impl ScopeManager {
             }
         }
     }
+
+    /// Lookup class variable in enclosing class scope.
+    ///
+    /// Note: Only searches `ScopeKind::Class` scopes. Module-scoped @@var and
+    /// inheritance-chain traversal are not supported in v0.2.0.
+    pub fn lookup_class_var(&self, name: &str) -> Option<VertexId> {
+        self.walk_scopes()
+            .find(|scope| matches!(&scope.kind, ScopeKind::Class { .. }))
+            .and_then(|scope| scope.get_class_var(name))
+    }
+
+    /// Set class variable in enclosing class scope.
+    ///
+    /// No-op if there is no enclosing `ScopeKind::Class` scope (e.g., top-level or module scope).
+    /// Module-scoped @@var support is planned for a future version.
+    pub fn set_class_var_in_class(&mut self, name: String, vtx: VertexId) {
+        let class_scope_id = self.walk_scopes()
+            .find(|scope| matches!(&scope.kind, ScopeKind::Class { .. }))
+            .map(|scope| scope.id);
+        if let Some(scope_id) = class_scope_id {
+            if let Some(scope) = self.scopes.get_mut(&scope_id) {
+                scope.set_class_var(name, vtx);
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_class_var_set_and_get() {
+        let mut scope = Scope::new(ScopeId(0), ScopeKind::TopLevel, None);
+        let vtx = VertexId(1);
+        scope.set_class_var("@@count".to_string(), vtx);
+        assert_eq!(scope.get_class_var("@@count"), Some(vtx));
+        assert_eq!(scope.get_class_var("@@missing"), None);
+    }
+
+    #[test]
+    fn test_lookup_class_var_from_method_scope() {
+        let mut manager = ScopeManager::new();
+
+        // Class scope
+        let class_id = manager.new_scope(ScopeKind::Class {
+            name: "Counter".to_string(),
+            superclass: None,
+        });
+        manager.enter_scope(class_id);
+
+        let vtx = VertexId(42);
+        manager.set_class_var_in_class("@@count".to_string(), vtx);
+
+        // Method scope (inside the class)
+        let method_id = manager.new_scope(ScopeKind::Method {
+            name: "increment".to_string(),
+            receiver_type: Some("Counter".to_string()),
+            return_vertex: None,
+        });
+        manager.enter_scope(method_id);
+
+        // Should find @@count through the class scope
+        assert_eq!(manager.lookup_class_var("@@count"), Some(vtx));
+    }
+
+    #[test]
+    fn test_set_class_var_noop_without_class_scope() {
+        let mut manager = ScopeManager::new();
+        // At top-level, no class scope exists
+        manager.set_class_var_in_class("@@var".to_string(), VertexId(1));
+        assert_eq!(manager.lookup_class_var("@@var"), None);
+    }
 }

data/core/src/graph/box.rs

@@ -112,6 +112,17 @@ impl MethodCallBox {
             return;
         }
 
+        if let Type::Proc { return_vertex, param_vertices, .. } = recv_ty {
+            if self.method_name == "call" {
+                if let Some(merge_vtx) = return_vertex {
+                    changes.add_edge(*merge_vtx, self.ret);
+                }
+                propagate_arguments(&self.arg_vtxs, Some(param_vertices), changes);
+            }
+            // TODO: Proc#arity, Proc#curry etc. not yet resolved via RBS
+            return;
+        }
+
         if let Some(method_info) = genv.resolve_method(recv_ty, &self.method_name) {
             if let Some(return_vtx) = method_info.return_vertex {
                 // User-defined method: connect body's return vertex to call site

data/core/src/types.rs

@@ -141,6 +141,10 @@ pub enum Type {
     Union(Vec<Type>),
     /// Bottom type: no type information
     Bot,
+    Proc {
+        return_vertex: Option<crate::graph::VertexId>,
+        param_vertices: Vec<crate::graph::VertexId>,
+    },
 }
 
 impl Type {
@@ -159,6 +163,10 @@ impl Type {
                 names.join(" | ")
             }
             Type::Bot => "untyped".to_string(),
+            Type::Proc { param_vertices, .. } => {
+                let params = vec!["untyped"; param_vertices.len()];
+                format!("Proc[({})->untyped]", params.join(", "))
+            }
         }
     }
 
@@ -277,6 +285,16 @@ impl Type {
         }
     }
 
+    pub fn proc_type_with_vertex(
+        return_vertex: crate::graph::VertexId,
+        param_vertices: Vec<crate::graph::VertexId>,
+    ) -> Self {
+        Type::Proc {
+            return_vertex: Some(return_vertex),
+            param_vertices,
+        }
+    }
+
     /// Collapse a Vec<Type> into a single Type or Union.
     /// Returns the single element if len==1, or Union if len>1.
     /// Panics if the vec is empty.
@@ -417,4 +435,20 @@ mod tests {
         assert_eq!(singleton.show(), "singleton(Api::User)");
         assert_eq!(singleton.base_class_name(), Some("Api::User"));
     }
+
+    #[test]
+    fn test_proc_type_show() {
+        let proc_ty = Type::Proc {
+            return_vertex: None,
+            param_vertices: vec![crate::graph::VertexId(99)],
+        };
+        assert_eq!(proc_ty.show(), "Proc[(untyped)->untyped]");
+
+        let proc_no_params = Type::Proc {
+            return_vertex: None,
+            param_vertices: vec![],
+        };
+        assert_eq!(proc_no_params.show(), "Proc[()->untyped]");
+    }
+
 }

data/ext/Cargo.toml

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

data/lib/methodray/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: method-ray
 version: !ruby/object:Gem::Version
-  version: 0.1.10
+  version: 0.2.0
 platform: ruby
 authors:
 - dak2
@@ -43,11 +43,13 @@ files:
 - core/src/analyzer/attributes.rs
 - core/src/analyzer/blocks.rs
 - core/src/analyzer/calls.rs
+- core/src/analyzer/compound_assignments.rs
 - core/src/analyzer/conditionals.rs
 - core/src/analyzer/definitions.rs
 - core/src/analyzer/dispatch.rs
 - core/src/analyzer/exceptions.rs
 - core/src/analyzer/install.rs
+- core/src/analyzer/lambdas.rs
 - core/src/analyzer/literals.rs
 - core/src/analyzer/loops.rs
 - core/src/analyzer/mod.rs
@@ -57,6 +59,7 @@ files:
 - core/src/analyzer/returns.rs
 - core/src/analyzer/super_calls.rs
 - core/src/analyzer/variables.rs
+- core/src/analyzer/yields.rs
 - core/src/cache/mod.rs
 - core/src/cache/rbs_cache.rs
 - core/src/checker.rs