method-ray 0.1.6 → 0.1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ee779223feab7110e29256fdc4860ba480d13d676d18e85284fd0765eef2cc4b
-  data.tar.gz: 249087d8f6b7772aa7428a4828ffc35eacb1b0aa8b27d5cd909b803176d6a683
+  metadata.gz: 3b5b60b4408b5e547cb40911fb0eb68d4dce182bc32fdf1ce3e6c8cd25f24975
+  data.tar.gz: 44f0b585ad8f2c83568d0df520711b2c1d09affd6fded8e35fbc3f27b082f073
 SHA512:
-  metadata.gz: 8d6534a955eaf4937c5ebc4c525e07f5f7cd8599861f128cbb10161e00a6a932f1b47760e1283e7e2f48940ea0a89bb5c038ac83cdd8ce8a629f8f91b05e534a
-  data.tar.gz: cbe0d247ffcbd0ce4965f9e20a2293336aca3d7a6eeb96878665cb7692e11ea4366d3c1f2a87ea32711dbcd00a404d4a41da3e84d34829d40568ec0bb37d74b4
+  metadata.gz: 1a7988edfb76b4fe4d1e03b8558104cc378299ebf8651b79dfc743e0e48b9cd4a04d235be1ca054f3ad172f9b7a8b0689e4bf99250935c02ab5cedb0737f1340
+  data.tar.gz: b6d94d5ce791e5b8317a880e986d60618a017434bc5823412dba3c8a04dcf3fb25089dff2a86e3662ecb7c2cdd13790cd32d5b18bc73960cf488ad8e8849a35b

data/CHANGELOG.md

@@ -5,6 +5,20 @@ 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.7] - 2026-03-07
+
+### Added
+
+- Kernel/Object methods loaded from RBS to reduce false positives ([#39](https://github.com/dak2/method-ray/pull/39))
+- Object/Kernel fallback chain for method resolution ([#40](https://github.com/dak2/method-ray/pull/40))
+- Constant namespace resolution for ConstantReadNode in nested scopes ([#41](https://github.com/dak2/method-ray/pull/41))
+- Cargo test added to CI workflow ([#38](https://github.com/dak2/method-ray/pull/38))
+
+### Changed
+
+- Extract `bytes_to_name` helper to consolidate 17 UTF-8 conversion sites ([#42](https://github.com/dak2/method-ray/pull/42))
+- Refactor MethodCallBox by extracting helper methods ([#43](https://github.com/dak2/method-ray/pull/43))
+
 ## [0.1.6] - 2026-02-23
 
 ### Fixed
@@ -95,6 +109,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.7]: https://github.com/dak2/method-ray/releases/tag/v0.1.7
 [0.1.6]: https://github.com/dak2/method-ray/releases/tag/v0.1.6
 [0.1.5]: https://github.com/dak2/method-ray/releases/tag/v0.1.5
 [0.1.4]: https://github.com/dak2/method-ray/releases/tag/v0.1.4

data/lib/methodray/version.rb

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

data/rust/Cargo.toml

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

data/rust/src/analyzer/blocks.rs

@@ -8,6 +8,7 @@
 use crate::env::{GlobalEnv, LocalEnv, ScopeKind};
 use crate::graph::{ChangeSet, VertexId};
 
+use super::bytes_to_name;
 use super::parameters::{install_optional_parameter, install_required_parameter, install_rest_parameter};
 
 /// Process block node
@@ -68,7 +69,7 @@ fn install_block_parameters_with_vtxs(
         // Required parameters (most common in blocks)
         for node in params.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_block_parameter(genv, lenv, name);
                 vtxs.push(vtx);
             }
@@ -77,7 +78,7 @@ fn install_block_parameters_with_vtxs(
         // Optional parameters: { |x = 1| ... }
         for node in params.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();
 
                 if let Some(default_vtx) =
@@ -97,7 +98,7 @@ fn install_block_parameters_with_vtxs(
         if let Some(rest_node) = params.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());
                     let vtx = install_rest_parameter(genv, lenv, name);
                     vtxs.push(vtx);
                 }

data/rust/src/analyzer/definitions.rs

@@ -11,6 +11,7 @@ use crate::graph::{ChangeSet, VertexId};
 use crate::types::Type;
 use ruby_prism::Node;
 
+use super::bytes_to_name;
 use super::install::install_statements;
 use super::parameters::install_parameters;
 
@@ -64,7 +65,7 @@ pub(crate) fn process_def_node(
     source: &str,
     def_node: &ruby_prism::DefNode,
 ) -> Option<VertexId> {
-    let method_name = String::from_utf8_lossy(def_node.name().as_slice()).to_string();
+    let method_name = bytes_to_name(def_node.name().as_slice());
 
     // Check if this is a class method (def self.foo)
     let is_class_method = def_node
@@ -163,7 +164,7 @@ fn extract_module_name(module_node: &ruby_prism::ModuleNode) -> String {
 pub(crate) 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());
+        return Some(bytes_to_name(constant_read.name().as_slice()));
     }
 
     // Constant path: `Api::User` or `Api::V1::User`
@@ -171,7 +172,7 @@ pub(crate) fn extract_constant_path(node: &Node) -> Option<String> {
         // 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())?;
+            .map(|id| bytes_to_name(id.as_slice()))?;
 
         // Get parent path if exists
         if let Some(parent_node) = constant_path.parent() {

data/rust/src/analyzer/dispatch.rs

@@ -9,6 +9,7 @@ use crate::source_map::SourceLocation;
 use crate::types::Type;
 use ruby_prism::Node;
 
+use super::bytes_to_name;
 use super::calls::install_method_call;
 use super::variables::{
     install_ivar_read, install_ivar_write, install_local_var_read, install_local_var_write,
@@ -68,7 +69,7 @@ pub enum NeedsChildKind<'a> {
 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() {
-        let ivar_name = String::from_utf8_lossy(ivar_read.name().as_slice()).to_string();
+        let ivar_name = bytes_to_name(ivar_read.name().as_slice());
         return match install_ivar_read(genv, &ivar_name) {
             Some(vtx) => DispatchResult::Vertex(vtx),
             None => DispatchResult::NotHandled,
@@ -82,17 +83,19 @@ pub fn dispatch_simple(genv: &mut GlobalEnv, lenv: &mut LocalEnv, node: &Node) -
 
     // Local variable read: x
     if let Some(read_node) = node.as_local_variable_read_node() {
-        let var_name = String::from_utf8_lossy(read_node.name().as_slice()).to_string();
+        let var_name = bytes_to_name(read_node.name().as_slice());
         return match install_local_var_read(lenv, &var_name) {
             Some(vtx) => DispatchResult::Vertex(vtx),
             None => DispatchResult::NotHandled,
         };
     }
 
-    // ConstantReadNode: User → Type::Singleton("User")
+    // ConstantReadNode: User → Type::Singleton("User") or Type::Singleton("Api::User")
     if let Some(const_read) = node.as_constant_read_node() {
-        let name = String::from_utf8_lossy(const_read.name().as_slice()).to_string();
-        let vtx = genv.new_source(Type::singleton(&name));
+        let name = bytes_to_name(const_read.name().as_slice());
+        let resolved_name = genv.scope_manager.lookup_constant(&name)
+            .unwrap_or(name);
+        let vtx = genv.new_source(Type::singleton(&resolved_name));
         return DispatchResult::Vertex(vtx);
     }
 
@@ -116,7 +119,7 @@ fn extract_symbol_names(call_node: &ruby_prism::CallNode) -> Vec<String> {
                 .iter()
                 .filter_map(|arg| {
                     arg.as_symbol_node().map(|sym| {
-                        String::from_utf8_lossy(&sym.unescaped()).to_string()
+                        bytes_to_name(sym.unescaped())
                     })
                 })
                 .collect()
@@ -128,7 +131,7 @@ fn extract_symbol_names(call_node: &ruby_prism::CallNode) -> Vec<String> {
 pub fn dispatch_needs_child<'a>(node: &Node<'a>, source: &str) -> Option<NeedsChildKind<'a>> {
     // Instance variable write: @name = value
     if let Some(ivar_write) = node.as_instance_variable_write_node() {
-        let ivar_name = String::from_utf8_lossy(ivar_write.name().as_slice()).to_string();
+        let ivar_name = bytes_to_name(ivar_write.name().as_slice());
         return Some(NeedsChildKind::IvarWrite {
             ivar_name,
             value: ivar_write.value(),
@@ -137,7 +140,7 @@ pub fn dispatch_needs_child<'a>(node: &Node<'a>, source: &str) -> Option<NeedsCh
 
     // Local variable write: x = value
     if let Some(write_node) = node.as_local_variable_write_node() {
-        let var_name = String::from_utf8_lossy(write_node.name().as_slice()).to_string();
+        let var_name = bytes_to_name(write_node.name().as_slice());
         return Some(NeedsChildKind::LocalVarWrite {
             var_name,
             value: write_node.value(),
@@ -146,7 +149,7 @@ pub fn dispatch_needs_child<'a>(node: &Node<'a>, source: &str) -> Option<NeedsCh
 
     // Method call: x.upcase, x.each { |i| ... }, or name (implicit self)
     if let Some(call_node) = node.as_call_node() {
-        let method_name = String::from_utf8_lossy(call_node.name().as_slice()).to_string();
+        let method_name = bytes_to_name(call_node.name().as_slice());
         let block = call_node.block();
         let arguments: Vec<Node<'a>> = call_node
             .arguments()
@@ -463,8 +466,8 @@ end
 
         // Utils.run should be registered
         let info = genv
-            .resolve_method(&Type::instance("Utils"), "run")
-            .expect("Utils#run should be registered");
+            .resolve_method(&Type::singleton("Utils"), "run")
+            .expect("Utils.run should be registered");
         assert!(info.return_vertex.is_some());
     }
 
@@ -893,4 +896,88 @@ Api::User.new.name
             genv.type_errors
         );
     }
+
+    // Test 23: ConstantReadNode inside module resolves to qualified name
+    #[test]
+    fn test_constant_read_inside_module_resolves_qualified() {
+        let source = r#"
+module Api
+  class User
+    def name
+      "Alice"
+    end
+  end
+
+  class Service
+    def run
+      User.new.name
+    end
+  end
+end
+"#;
+        let genv = analyze(source);
+        assert!(
+            genv.type_errors.is_empty(),
+            "User.new inside module Api should resolve to Api::User: {:?}",
+            genv.type_errors
+        );
+    }
+
+    // Test 24: ConstantReadNode in deeply nested modules
+    #[test]
+    fn test_constant_read_deeply_nested() {
+        let source = r#"
+module Api
+  module V1
+    class User
+      def name
+        "Alice"
+      end
+    end
+
+    class Service
+      def run
+        User.new.name
+      end
+    end
+  end
+end
+"#;
+        let genv = analyze(source);
+        assert!(
+            genv.type_errors.is_empty(),
+            "User.new inside Api::V1 should resolve to Api::V1::User: {:?}",
+            genv.type_errors
+        );
+    }
+
+    // Test 25: Same constant name in different modules
+    #[test]
+    fn test_constant_read_same_name_different_modules() {
+        let source = r#"
+module Api
+  class User
+    def name; "Api User"; end
+  end
+end
+
+module Admin
+  class User
+    def name; "Admin User"; end
+  end
+
+  class Service
+    def run
+      User.new.name
+    end
+  end
+end
+"#;
+        let genv = analyze(source);
+        assert!(
+            genv.type_errors.is_empty(),
+            "User.new inside Admin should resolve to Admin::User: {:?}",
+            genv.type_errors
+        );
+    }
 }

data/rust/src/analyzer/mod.rs

@@ -13,3 +13,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/parameters.rs

@@ -9,6 +9,8 @@ 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
@@ -129,7 +131,7 @@ pub(crate) fn install_parameters(
     // 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 +140,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,7 +159,7 @@ 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);
             }
         }
@@ -168,7 +170,7 @@ pub(crate) fn install_parameters(
     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);
             }
         }

data/rust/src/env/global_env.rs

@@ -71,6 +71,21 @@ impl GlobalEnv {
         self.vertex_manager.get_source(id)
     }
 
+    /// Get the types associated with a vertex ID (handles both Vertex and Source)
+    ///
+    /// Returns `None` if neither a Vertex nor Source exists for this ID.
+    /// Returns `Some(vec![])` if a Vertex exists but has no types yet (e.g., unresolved block parameters).
+    /// Returns `Some(vec![ty])` if a Source exists (always exactly one type).
+    pub fn get_receiver_types(&self, id: VertexId) -> Option<Vec<Type>> {
+        if let Some(vertex) = self.get_vertex(id) {
+            Some(vertex.types.keys().cloned().collect())
+        } else if let Some(source) = self.get_source(id) {
+            Some(vec![source.ty.clone()])
+        } else {
+            None
+        }
+    }
+
     /// Add edge (immediate type propagation)
     pub fn add_edge(&mut self, src: VertexId, dst: VertexId) {
         self.vertex_manager.add_edge(src, dst);
@@ -189,20 +204,36 @@ impl GlobalEnv {
 
     // ===== Scope Management =====
 
+    /// Register a constant (simple name → qualified name) in the parent scope
+    fn register_constant_in_parent(&mut self, scope_id: ScopeId, name: &str) {
+        if name.contains("::") { return; }
+        let qualified = self.scope_manager.current_qualified_name()
+            .unwrap_or_else(|| name.to_string());
+        if let Some(parent_id) = self.scope_manager.get_scope(scope_id)
+            .and_then(|s| s.parent)
+        {
+            if let Some(parent_scope) = self.scope_manager.get_scope_mut(parent_id) {
+                parent_scope.constants.insert(name.to_string(), qualified);
+            }
+        }
+    }
+
     /// Enter a class scope
     pub fn enter_class(&mut self, name: String) -> ScopeId {
         let scope_id = self.scope_manager.new_scope(ScopeKind::Class {
-            name,
+            name: name.clone(),
             superclass: None,
         });
         self.scope_manager.enter_scope(scope_id);
+        self.register_constant_in_parent(scope_id, &name);
         scope_id
     }
 
     /// Enter a module scope
     pub fn enter_module(&mut self, name: String) -> ScopeId {
-        let scope_id = self.scope_manager.new_scope(ScopeKind::Module { name });
+        let scope_id = self.scope_manager.new_scope(ScopeKind::Module { name: name.clone() });
         self.scope_manager.enter_scope(scope_id);
+        self.register_constant_in_parent(scope_id, &name);
         scope_id
     }
 

data/rust/src/env/method_registry.rs

@@ -2,8 +2,12 @@
 
 use crate::graph::VertexId;
 use crate::types::Type;
+use smallvec::SmallVec;
 use std::collections::HashMap;
 
+const OBJECT_CLASS: &str = "Object";
+const KERNEL_MODULE: &str = "Kernel";
+
 /// Method information
 #[derive(Debug, Clone)]
 pub struct MethodInfo {
@@ -70,26 +74,40 @@ impl MethodRegistry {
         );
     }
 
-    /// Resolve a method for a receiver type
+    /// Build the method resolution order (MRO) fallback chain for a receiver type.
     ///
-    /// For generic types like `Array[Integer]`, first tries exact match,
-    /// then falls back to base class match (`Array`).
-    pub fn resolve(&self, recv_ty: &Type, method_name: &str) -> Option<&MethodInfo> {
-        // First, try exact match
-        if let Some(info) = self
-            .methods
-            .get(&(recv_ty.clone(), method_name.to_string()))
-        {
-            return Some(info);
-        }
+    /// Returns a list of types to search in order:
+    /// 1. Exact receiver type
+    /// 2. Generic → base class (e.g., Array[Integer] → Array)
+    /// 3. Object (for Instance/Generic types only)
+    /// 4. Kernel (for Instance/Generic types only)
+    fn fallback_chain(recv_ty: &Type) -> SmallVec<[Type; 4]> {
+        let mut chain = SmallVec::new();
+        chain.push(recv_ty.clone());
 
-        // For generic types, fall back to base class
         if let Type::Generic { name, .. } = recv_ty {
-            let base_type = Type::Instance { name: name.clone() };
-            return self.methods.get(&(base_type, method_name.to_string()));
+            chain.push(Type::Instance { name: name.clone() });
         }
 
-        None
+        // NOTE: Kernel is a module, not a class. Represented as Type::Instance
+        // due to lack of Type::Module variant.
+        if matches!(recv_ty, Type::Instance { .. } | Type::Generic { .. }) {
+            chain.push(Type::instance(OBJECT_CLASS));
+            chain.push(Type::instance(KERNEL_MODULE));
+        }
+
+        chain
+    }
+
+    /// Resolve a method for a receiver type
+    ///
+    /// Searches the MRO fallback chain: exact type → base class (for generics) → Object → Kernel.
+    /// For non-instance types (Singleton, Nil, Union, Bot), only exact match is attempted.
+    pub fn resolve(&self, recv_ty: &Type, method_name: &str) -> Option<&MethodInfo> {
+        let method_key = method_name.to_string();
+        Self::fallback_chain(recv_ty)
+            .into_iter()
+            .find_map(|ty| self.methods.get(&(ty, method_key.clone())))
     }
 }
 
@@ -142,4 +160,103 @@ mod tests {
         assert_eq!(pvs[0], VertexId(20));
         assert_eq!(pvs[1], VertexId(21));
     }
+
+    // --- Object/Kernel fallback ---
+
+    #[test]
+    fn test_resolve_falls_back_to_object() {
+        let mut registry = MethodRegistry::new();
+        registry.register(Type::instance("Object"), "nil?", Type::instance("TrueClass"));
+        let info = registry.resolve(&Type::instance("CustomClass"), "nil?").unwrap();
+        assert_eq!(info.return_type.base_class_name(), Some("TrueClass"));
+    }
+
+    #[test]
+    fn test_resolve_falls_back_to_kernel() {
+        let mut registry = MethodRegistry::new();
+        registry.register(Type::instance("Kernel"), "puts", Type::Nil);
+        let info = registry.resolve(&Type::instance("MyApp"), "puts").unwrap();
+        assert_eq!(info.return_type, Type::Nil);
+    }
+
+    #[test]
+    fn test_resolve_object_before_kernel() {
+        let mut registry = MethodRegistry::new();
+        registry.register(Type::instance("Object"), "to_s", Type::string());
+        registry.register(Type::instance("Kernel"), "to_s", Type::integer());
+        let info = registry.resolve(&Type::instance("Anything"), "to_s").unwrap();
+        assert_eq!(info.return_type.base_class_name(), Some("String"));
+    }
+
+    #[test]
+    fn test_resolve_exact_match_over_fallback() {
+        let mut registry = MethodRegistry::new();
+        registry.register(Type::string(), "length", Type::integer());
+        registry.register(Type::instance("Object"), "length", Type::string());
+        let info = registry.resolve(&Type::string(), "length").unwrap();
+        assert_eq!(info.return_type.base_class_name(), Some("Integer"));
+    }
+
+    // --- Types that skip fallback ---
+
+    #[test]
+    fn test_singleton_type_skips_fallback() {
+        let mut registry = MethodRegistry::new();
+        registry.register(Type::instance("Kernel"), "puts", Type::Nil);
+        assert!(registry.resolve(&Type::singleton("User"), "puts").is_none());
+    }
+
+    #[test]
+    fn test_nil_type_skips_fallback() {
+        let mut registry = MethodRegistry::new();
+        registry.register(Type::instance("Kernel"), "puts", Type::Nil);
+        assert!(registry.resolve(&Type::Nil, "puts").is_none());
+    }
+
+    #[test]
+    fn test_union_type_skips_fallback() {
+        let mut registry = MethodRegistry::new();
+        registry.register(Type::instance("Kernel"), "puts", Type::Nil);
+        let union_ty = Type::Union(vec![Type::string(), Type::integer()]);
+        assert!(registry.resolve(&union_ty, "puts").is_none());
+    }
+
+    #[test]
+    fn test_bot_type_skips_fallback() {
+        let mut registry = MethodRegistry::new();
+        registry.register(Type::instance("Kernel"), "puts", Type::Nil);
+        assert!(registry.resolve(&Type::Bot, "puts").is_none());
+    }
+
+    // --- Generic type fallback chain ---
+
+    #[test]
+    fn test_resolve_generic_falls_back_to_kernel() {
+        let mut registry = MethodRegistry::new();
+        registry.register(Type::instance("Kernel"), "puts", Type::Nil);
+        let generic_type = Type::array_of(Type::integer());
+        let info = registry.resolve(&generic_type, "puts").unwrap();
+        assert_eq!(info.return_type, Type::Nil);
+    }
+
+    #[test]
+    fn test_resolve_generic_full_chain() {
+        // Verify the 4-step fallback: Generic[T] → Base → Object → Kernel
+        let mut registry = MethodRegistry::new();
+        registry.register(Type::instance("Kernel"), "object_id", Type::integer());
+        let generic_type = Type::array_of(Type::string());
+        // Array[String] → Array (none) → Object (none) → Kernel (exists)
+        let info = registry.resolve(&generic_type, "object_id").unwrap();
+        assert_eq!(info.return_type.base_class_name(), Some("Integer"));
+    }
+
+    // --- Namespaced class fallback ---
+
+    #[test]
+    fn test_resolve_namespaced_class_falls_back_to_object() {
+        let mut registry = MethodRegistry::new();
+        registry.register(Type::instance("Object"), "class", Type::string());
+        let info = registry.resolve(&Type::instance("Api::V1::User"), "class").unwrap();
+        assert_eq!(info.return_type.base_class_name(), Some("String"));
+    }
 }

data/rust/src/env/scope.rs

@@ -41,6 +41,9 @@ pub struct Scope {
 
     /// Class variables (class scope only)
     pub class_vars: HashMap<String, VertexId>,
+
+    /// Constants (simple name → qualified name)
+    pub constants: HashMap<String, String>,
 }
 
 #[allow(dead_code)]
@@ -53,6 +56,7 @@ impl Scope {
             local_vars: HashMap::new(),
             instance_vars: HashMap::new(),
             class_vars: HashMap::new(),
+            constants: HashMap::new(),
         }
     }
 
@@ -135,6 +139,18 @@ impl ScopeManager {
         self.scopes.get_mut(&self.current_scope).unwrap()
     }
 
+    /// Walk scopes from current scope up to the top-level, yielding each scope
+    fn walk_scopes(&self) -> impl Iterator<Item = &Scope> + '_ {
+        let scopes = &self.scopes;
+        let mut current = Some(self.current_scope);
+        std::iter::from_fn(move || {
+            let scope_id = current?;
+            let scope = scopes.get(&scope_id)?;
+            current = scope.parent;
+            Some(scope)
+        })
+    }
+
     /// Get scope by ID
     pub fn get_scope(&self, id: ScopeId) -> Option<&Scope> {
         self.scopes.get(&id)
@@ -147,103 +163,54 @@ impl ScopeManager {
 
     /// Lookup variable in current scope or parent scopes
     pub fn lookup_var(&self, name: &str) -> Option<VertexId> {
-        let mut current = Some(self.current_scope);
-
-        while let Some(scope_id) = current {
-            if let Some(scope) = self.scopes.get(&scope_id) {
-                if let Some(vtx) = scope.get_local_var(name) {
-                    return Some(vtx);
-                }
-                current = scope.parent;
-            } else {
-                break;
-            }
-        }
+        self.walk_scopes().find_map(|scope| scope.get_local_var(name))
+    }
 
-        None
+    /// Lookup constant in current scope or parent scopes (simple name → qualified name)
+    pub fn lookup_constant(&self, simple_name: &str) -> Option<String> {
+        self.walk_scopes()
+            .find_map(|scope| scope.constants.get(simple_name).cloned())
     }
 
     /// Lookup instance variable in enclosing class scope
     pub fn lookup_instance_var(&self, name: &str) -> Option<VertexId> {
-        let mut current = Some(self.current_scope);
-
-        while let Some(scope_id) = current {
-            if let Some(scope) = self.scopes.get(&scope_id) {
-                // Walk up to class scope
-                match &scope.kind {
-                    ScopeKind::Class { .. } => {
-                        return scope.get_instance_var(name);
-                    }
-                    _ => {
-                        current = scope.parent;
-                    }
-                }
-            } else {
-                break;
-            }
-        }
-
-        None
+        self.walk_scopes()
+            .find(|scope| matches!(&scope.kind, ScopeKind::Class { .. }))
+            .and_then(|scope| scope.get_instance_var(name))
     }
 
     /// Set instance variable in enclosing class scope
     pub fn set_instance_var_in_class(&mut self, name: String, vtx: VertexId) {
-        let mut current = Some(self.current_scope);
-
-        while let Some(scope_id) = current {
-            if let Some(scope) = self.scopes.get(&scope_id) {
-                // Find class scope and set variable
-                match &scope.kind {
-                    ScopeKind::Class { .. } => {
-                        if let Some(class_scope) = self.scopes.get_mut(&scope_id) {
-                            class_scope.set_instance_var(name, vtx);
-                        }
-                        return;
-                    }
-                    _ => {
-                        current = scope.parent;
-                    }
-                }
-            } else {
-                break;
+        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_instance_var(name, vtx);
             }
         }
     }
 
     /// Get current class name (simple name, not qualified)
     pub fn current_class_name(&self) -> Option<String> {
-        let mut current = Some(self.current_scope);
-
-        while let Some(scope_id) = current {
-            if let Some(scope) = self.scopes.get(&scope_id) {
-                if let ScopeKind::Class { name, .. } = &scope.kind {
-                    return Some(name.clone());
-                }
-                current = scope.parent;
+        self.walk_scopes().find_map(|scope| {
+            if let ScopeKind::Class { name, .. } = &scope.kind {
+                Some(name.clone())
             } else {
-                break;
+                None
             }
-        }
-
-        None
+        })
     }
 
     /// Get current module name (simple name, not qualified)
     pub fn current_module_name(&self) -> Option<String> {
-        let mut current = Some(self.current_scope);
-
-        while let Some(scope_id) = current {
-            if let Some(scope) = self.scopes.get(&scope_id) {
-                if let ScopeKind::Module { name } = &scope.kind {
-                    return Some(name.clone());
-                }
-                current = scope.parent;
+        self.walk_scopes().find_map(|scope| {
+            if let ScopeKind::Module { name } = &scope.kind {
+                Some(name.clone())
             } else {
-                break;
+                None
             }
-        }
-
-        None
+        })
     }
 
     /// Get current fully qualified name by traversing all parent class/module scopes
@@ -260,36 +227,12 @@ impl ScopeManager {
     /// ```
     /// When inside `greet`, this returns `Some("Api::V1::User")`
     pub fn current_qualified_name(&self) -> Option<String> {
-        let mut path_segments: Vec<String> = Vec::new();
-        let mut current = Some(self.current_scope);
-
-        // Traverse from current scope up to top-level, collecting class/module names
-        while let Some(scope_id) = current {
-            if let Some(scope) = self.scopes.get(&scope_id) {
-                match &scope.kind {
-                    ScopeKind::Class { name, .. } => {
-                        // If the name already contains ::, it's a qualified name from AST
-                        // (e.g., `class Api::User` defined at top level)
-                        if name.contains("::") {
-                            path_segments.push(name.clone());
-                        } else {
-                            path_segments.push(name.clone());
-                        }
-                    }
-                    ScopeKind::Module { name } => {
-                        if name.contains("::") {
-                            path_segments.push(name.clone());
-                        } else {
-                            path_segments.push(name.clone());
-                        }
-                    }
-                    _ => {}
-                }
-                current = scope.parent;
-            } else {
-                break;
-            }
-        }
+        let mut path_segments: Vec<&str> = self.walk_scopes()
+            .filter_map(|scope| match &scope.kind {
+                ScopeKind::Class { name, .. } | ScopeKind::Module { name } => Some(name.as_str()),
+                _ => None,
+            })
+            .collect();
 
         if path_segments.is_empty() {
             return None;
@@ -297,76 +240,35 @@ impl ScopeManager {
 
         // Reverse to get from outermost to innermost
         path_segments.reverse();
-
-        // Join all segments, handling cases where segments may already contain ::
-        let mut result = String::new();
-        for segment in path_segments {
-            if !result.is_empty() {
-                result.push_str("::");
-            }
-            result.push_str(&segment);
-        }
-
-        Some(result)
+        Some(path_segments.join("::"))
     }
 
     /// Get return_vertex from the nearest enclosing method scope
     pub fn current_method_return_vertex(&self) -> Option<VertexId> {
-        let mut current = Some(self.current_scope);
-        while let Some(scope_id) = current {
-            if let Some(scope) = self.scopes.get(&scope_id) {
-                if let ScopeKind::Method { return_vertex, .. } = &scope.kind {
-                    return *return_vertex;
-                }
-                current = scope.parent;
+        self.walk_scopes().find_map(|scope| {
+            if let ScopeKind::Method { return_vertex, .. } = &scope.kind {
+                *return_vertex
             } else {
-                break;
+                None
             }
-        }
-        None
+        })
     }
 
     /// Lookup instance variable in enclosing module scope
     pub fn lookup_instance_var_in_module(&self, name: &str) -> Option<VertexId> {
-        let mut current = Some(self.current_scope);
-
-        while let Some(scope_id) = current {
-            if let Some(scope) = self.scopes.get(&scope_id) {
-                match &scope.kind {
-                    ScopeKind::Module { .. } => {
-                        return scope.get_instance_var(name);
-                    }
-                    _ => {
-                        current = scope.parent;
-                    }
-                }
-            } else {
-                break;
-            }
-        }
-
-        None
+        self.walk_scopes()
+            .find(|scope| matches!(&scope.kind, ScopeKind::Module { .. }))
+            .and_then(|scope| scope.get_instance_var(name))
     }
 
     /// Set instance variable in enclosing module scope
     pub fn set_instance_var_in_module(&mut self, name: String, vtx: VertexId) {
-        let mut current = Some(self.current_scope);
-
-        while let Some(scope_id) = current {
-            if let Some(scope) = self.scopes.get(&scope_id) {
-                match &scope.kind {
-                    ScopeKind::Module { .. } => {
-                        if let Some(module_scope) = self.scopes.get_mut(&scope_id) {
-                            module_scope.set_instance_var(name, vtx);
-                        }
-                        return;
-                    }
-                    _ => {
-                        current = scope.parent;
-                    }
-                }
-            } else {
-                break;
+        let module_scope_id = self.walk_scopes()
+            .find(|scope| matches!(&scope.kind, ScopeKind::Module { .. }))
+            .map(|scope| scope.id);
+        if let Some(scope_id) = module_scope_id {
+            if let Some(scope) = self.scopes.get_mut(&scope_id) {
+                scope.set_instance_var(name, vtx);
             }
         }
     }
@@ -614,4 +516,72 @@ mod tests {
         // At top level, no class/module
         assert_eq!(sm.current_qualified_name(), None);
     }
+
+    #[test]
+    fn test_constant_registration_and_lookup() {
+        let mut sm = ScopeManager::new();
+
+        // module Api
+        sm.current_scope_mut().constants.insert("Api".to_string(), "Api".to_string());
+        let api_id = sm.new_scope(ScopeKind::Module { name: "Api".to_string() });
+        sm.enter_scope(api_id);
+
+        // class User (inside Api) — register in parent scope (Api)
+        sm.current_scope_mut().constants.insert("User".to_string(), "Api::User".to_string());
+        let user_id = sm.new_scope(ScopeKind::Class {
+            name: "User".to_string(),
+            superclass: None,
+        });
+        sm.enter_scope(user_id);
+
+        assert_eq!(sm.lookup_constant("User"), Some("Api::User".to_string()));
+        assert_eq!(sm.lookup_constant("Api"), Some("Api".to_string()));
+        assert_eq!(sm.lookup_constant("Unknown"), None);
+    }
+
+    #[test]
+    fn test_constant_lookup_from_method_scope() {
+        let mut sm = ScopeManager::new();
+
+        sm.current_scope_mut().constants.insert("Api".to_string(), "Api".to_string());
+        let api_id = sm.new_scope(ScopeKind::Module { name: "Api".to_string() });
+        sm.enter_scope(api_id);
+
+        sm.current_scope_mut().constants.insert("User".to_string(), "Api::User".to_string());
+        let user_id = sm.new_scope(ScopeKind::Class {
+            name: "User".to_string(),
+            superclass: None,
+        });
+        sm.enter_scope(user_id);
+
+        let method_id = sm.new_scope(ScopeKind::Method {
+            name: "greet".to_string(),
+            receiver_type: None,
+            return_vertex: None,
+        });
+        sm.enter_scope(method_id);
+
+        // Should find constant by traversing parent scopes from method scope
+        assert_eq!(sm.lookup_constant("User"), Some("Api::User".to_string()));
+    }
+
+    #[test]
+    fn test_constant_same_name_different_namespaces() {
+        let mut sm = ScopeManager::new();
+
+        // module Api
+        let api_id = sm.new_scope(ScopeKind::Module { name: "Api".to_string() });
+        sm.enter_scope(api_id);
+        sm.current_scope_mut().constants.insert("User".to_string(), "Api::User".to_string());
+
+        sm.exit_scope();
+
+        // module Admin
+        let admin_id = sm.new_scope(ScopeKind::Module { name: "Admin".to_string() });
+        sm.enter_scope(admin_id);
+        sm.current_scope_mut().constants.insert("User".to_string(), "Admin::User".to_string());
+
+        // Inside Admin scope, User should resolve to Admin::User
+        assert_eq!(sm.lookup_constant("User"), Some("Admin::User".to_string()));
+    }
 }

data/rust/src/graph/box.rs

@@ -16,6 +16,18 @@ pub trait BoxTrait: Send + Sync {
     fn ret(&self) -> VertexId;
 }
 
+/// Propagate argument types to parameter vertices by adding edges
+/// from each argument vertex to the corresponding parameter vertex.
+fn propagate_arguments(
+    arg_vtxs: &[VertexId],
+    param_vtxs: Option<&[VertexId]>,
+    changes: &mut ChangeSet,
+) {
+    for (arg_vtx, param_vtx) in arg_vtxs.iter().zip(param_vtxs.unwrap_or_default()) {
+        changes.add_edge(*arg_vtx, *param_vtx);
+    }
+}
+
 /// Box representing a method call
 #[allow(dead_code)]
 pub struct MethodCallBox {
@@ -51,6 +63,77 @@ impl MethodCallBox {
             reschedule_count: 0,
         }
     }
+
+    /// Reschedule this box for re-execution if the limit hasn't been reached.
+    /// Handles cases where the receiver has no types yet (e.g., block parameters
+    /// that get typed by a later box). If max reschedules are reached, the box
+    /// is silently dropped (receiver type remains unknown).
+    fn try_reschedule(&mut self, changes: &mut ChangeSet) {
+        if self.reschedule_count < MAX_RESCHEDULE_COUNT {
+            self.reschedule_count += 1;
+            changes.reschedule(self.id);
+        }
+    }
+
+    fn process_recv_type(
+        &self,
+        recv_ty: &Type,
+        genv: &mut GlobalEnv,
+        changes: &mut ChangeSet,
+    ) {
+        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
+                changes.add_edge(return_vtx, self.ret);
+                propagate_arguments(
+                    &self.arg_vtxs,
+                    method_info.param_vertices.as_deref(),
+                    changes,
+                );
+            } else {
+                // Builtin/RBS method: create source with fixed return type
+                let ret_src_id = genv.new_source(method_info.return_type.clone());
+                changes.add_edge(ret_src_id, self.ret);
+            }
+        } else if self.method_name == "new" {
+            self.handle_new_call(recv_ty, genv, changes);
+        } else if !matches!(recv_ty, Type::Singleton { .. }) {
+            // Singleton types with unresolved methods are silently skipped;
+            // these are typically RBS class methods not yet supported.
+            self.report_type_error(recv_ty, genv);
+        }
+    }
+
+    /// Handle `.new` calls: singleton(Foo)#new produces instance(Foo),
+    /// and propagates arguments to the `initialize` method's parameters.
+    fn handle_new_call(
+        &self,
+        recv_ty: &Type,
+        genv: &mut GlobalEnv,
+        changes: &mut ChangeSet,
+    ) {
+        if let Type::Singleton { name } = recv_ty {
+            let instance_type = Type::instance(name.full_name());
+
+            let ret_src = genv.new_source(instance_type.clone());
+            changes.add_edge(ret_src, self.ret);
+
+            let init_params = genv
+                .resolve_method(&instance_type, "initialize")
+                .and_then(|info| info.param_vertices.as_deref());
+            propagate_arguments(&self.arg_vtxs, init_params, changes);
+        } else {
+            self.report_type_error(recv_ty, genv);
+        }
+    }
+
+    fn report_type_error(&self, recv_ty: &Type, genv: &mut GlobalEnv) {
+        genv.record_type_error(
+            recv_ty.clone(),
+            self.method_name.clone(),
+            self.location.clone(),
+        );
+    }
 }
 
 impl BoxTrait for MethodCallBox {
@@ -63,88 +146,17 @@ impl BoxTrait for MethodCallBox {
     }
 
     fn run(&mut self, genv: &mut GlobalEnv, changes: &mut ChangeSet) {
-        // Get receiver type (handles both Vertex and Source)
-        let recv_types: Vec<Type> = if let Some(recv_vertex) = genv.get_vertex(self.recv) {
-            // Vertex case: may have multiple types
-            recv_vertex.types.keys().cloned().collect()
-        } else if let Some(recv_source) = genv.get_source(self.recv) {
-            // Source case: has one fixed type (e.g., literals)
-            vec![recv_source.ty.clone()]
-        } else {
-            // Receiver not found
+        let Some(recv_types) = genv.get_receiver_types(self.recv) else {
             return;
         };
 
-        // If receiver has no types yet, reschedule this box for later
-        // This handles cases like block parameters that are typed later
         if recv_types.is_empty() {
-            if self.reschedule_count < MAX_RESCHEDULE_COUNT {
-                self.reschedule_count += 1;
-                changes.reschedule(self.id);
-            }
-            // If max reschedules reached, just skip (receiver type is unknown)
+            self.try_reschedule(changes);
             return;
         }
 
         for recv_ty in recv_types {
-            // Resolve method
-            if let Some(method_info) = genv.resolve_method(&recv_ty, &self.method_name) {
-                if let Some(return_vtx) = method_info.return_vertex {
-                    // User-defined: edge from body's last expr → call site return
-                    changes.add_edge(return_vtx, self.ret);
-
-                    // Propagate argument types to parameter vertices
-                    if let Some(param_vtxs) = &method_info.param_vertices {
-                        for (i, param_vtx) in param_vtxs.iter().enumerate() {
-                            if let Some(arg_vtx) = self.arg_vtxs.get(i) {
-                                changes.add_edge(*arg_vtx, *param_vtx);
-                            }
-                        }
-                    }
-                } else {
-                    // RBS/builtin: create Source with fixed return type
-                    let ret_src_id = genv.new_source(method_info.return_type.clone());
-                    changes.add_edge(ret_src_id, self.ret);
-                }
-            } else if self.method_name == "new" {
-                if let Type::Singleton { name } = &recv_ty {
-                    // singleton(User)#new → instance(User)
-                    let instance_type = Type::instance(name.full_name());
-                    let ret_src = genv.new_source(instance_type.clone());
-                    changes.add_edge(ret_src, self.ret);
-
-                    // Propagate arguments to initialize parameters
-                    if let Some(init_info) = genv.resolve_method(&instance_type, "initialize") {
-                        if let Some(param_vtxs) = &init_info.param_vertices {
-                            for (i, param_vtx) in param_vtxs.iter().enumerate() {
-                                if let Some(arg_vtx) = self.arg_vtxs.get(i) {
-                                    changes.add_edge(*arg_vtx, *param_vtx);
-                                }
-                            }
-                        }
-                    }
-                    continue;
-                }
-                // Non-singleton .new: record error
-                genv.record_type_error(
-                    recv_ty.clone(),
-                    self.method_name.clone(),
-                    self.location.clone(),
-                );
-            } else if matches!(&recv_ty, Type::Singleton { .. }) {
-                // Skip error for unknown class methods on Singleton types.
-                // User-defined class methods (def self.foo) are resolved by
-                // resolve_method above. Only unresolved methods reach here
-                // (e.g., RBS class methods not yet supported).
-                continue;
-            } else {
-                // Record type error for diagnostic reporting
-                genv.record_type_error(
-                    recv_ty.clone(),
-                    self.method_name.clone(),
-                    self.location.clone(),
-                );
-            }
+            self.process_recv_type(&recv_ty, genv, changes);
         }
     }
 }
@@ -241,12 +253,7 @@ impl BoxTrait for BlockParameterTypeBox {
     }
 
     fn run(&mut self, genv: &mut GlobalEnv, changes: &mut ChangeSet) {
-        // Get receiver types
-        let recv_types: Vec<Type> = if let Some(recv_vertex) = genv.get_vertex(self.recv_vtx) {
-            recv_vertex.types.keys().cloned().collect()
-        } else if let Some(recv_source) = genv.get_source(self.recv_vtx) {
-            vec![recv_source.ty.clone()]
-        } else {
+        let Some(recv_types) = genv.get_receiver_types(self.recv_vtx) else {
             return;
         };
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: method-ray
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 0.1.7
 platform: ruby
 authors:
 - dak2