method-ray 0.1.8 → 0.1.10

data/core/src/env/scope.rs

@@ -0,0 +1,299 @@
+use crate::graph::VertexId;
+use std::collections::HashMap;
+
+/// Scope ID
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct ScopeId(pub usize);
+
+/// Scope kind
+#[derive(Debug, Clone)]
+pub enum ScopeKind {
+    TopLevel,
+    Class {
+        name: String,
+        superclass: Option<String>,
+    },
+    Module {
+        name: String,
+    },
+    Method {
+        name: String,
+        receiver_type: Option<String>, // Receiver class/module name
+        return_vertex: Option<VertexId>, // Merge vertex for return statements
+    },
+    Block,
+}
+
+/// Scope information
+#[derive(Debug, Clone)]
+pub struct Scope {
+    pub id: ScopeId,
+    pub kind: ScopeKind,
+    pub parent: Option<ScopeId>,
+
+    /// Local variables
+    pub local_vars: HashMap<String, VertexId>,
+
+    /// Instance variables (class/module scope only)
+    pub instance_vars: HashMap<String, VertexId>,
+
+    /// Class variables (class scope only)
+    pub class_vars: HashMap<String, VertexId>,
+
+    /// Constants (simple name → qualified name)
+    pub constants: HashMap<String, String>,
+}
+
+impl Scope {
+    pub fn new(id: ScopeId, kind: ScopeKind, parent: Option<ScopeId>) -> Self {
+        Self {
+            id,
+            kind,
+            parent,
+            local_vars: HashMap::new(),
+            instance_vars: HashMap::new(),
+            class_vars: HashMap::new(),
+            constants: HashMap::new(),
+        }
+    }
+
+    /// Add local variable
+    pub fn set_local_var(&mut self, name: String, vtx: VertexId) {
+        self.local_vars.insert(name, vtx);
+    }
+
+    /// Get local variable
+    pub fn get_local_var(&self, name: &str) -> Option<VertexId> {
+        self.local_vars.get(name).copied()
+    }
+
+    /// Add instance variable
+    pub fn set_instance_var(&mut self, name: String, vtx: VertexId) {
+        self.instance_vars.insert(name, vtx);
+    }
+
+    /// Get instance variable
+    pub fn get_instance_var(&self, name: &str) -> Option<VertexId> {
+        self.instance_vars.get(name).copied()
+    }
+}
+
+/// Scope manager
+#[derive(Debug)]
+pub struct ScopeManager {
+    scopes: HashMap<ScopeId, Scope>,
+    next_id: usize,
+    current_scope: ScopeId,
+}
+
+impl Default for ScopeManager {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl ScopeManager {
+    pub fn new() -> Self {
+        let top_level = Scope::new(ScopeId(0), ScopeKind::TopLevel, None);
+
+        let mut scopes = HashMap::new();
+        scopes.insert(ScopeId(0), top_level);
+
+        Self {
+            scopes,
+            next_id: 1,
+            current_scope: ScopeId(0),
+        }
+    }
+
+    /// Create a new scope
+    pub fn new_scope(&mut self, kind: ScopeKind) -> ScopeId {
+        let id = ScopeId(self.next_id);
+        self.next_id += 1;
+
+        let scope = Scope::new(id, kind, Some(self.current_scope));
+        self.scopes.insert(id, scope);
+
+        id
+    }
+
+    /// Enter a scope
+    pub fn enter_scope(&mut self, scope_id: ScopeId) {
+        self.current_scope = scope_id;
+    }
+
+    /// Exit current scope
+    pub fn exit_scope(&mut self) {
+        if let Some(scope) = self.scopes.get(&self.current_scope) {
+            if let Some(parent) = scope.parent {
+                self.current_scope = parent;
+            }
+        }
+    }
+
+    /// Get current scope
+    pub fn current_scope(&self) -> &Scope {
+        self.scopes.get(&self.current_scope).unwrap()
+    }
+
+    /// Get current scope mutably
+    pub fn current_scope_mut(&mut self) -> &mut Scope {
+        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)
+    }
+
+    /// Get scope by ID mutably
+    pub fn get_scope_mut(&mut self, id: ScopeId) -> Option<&mut Scope> {
+        self.scopes.get_mut(&id)
+    }
+
+    /// Lookup variable in current scope or parent scopes
+    pub fn lookup_var(&self, name: &str) -> Option<VertexId> {
+        self.walk_scopes().find_map(|scope| scope.get_local_var(name))
+    }
+
+    /// 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> {
+        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 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> {
+        self.walk_scopes().find_map(|scope| {
+            if let ScopeKind::Class { name, .. } = &scope.kind {
+                Some(name.clone())
+            } else {
+                None
+            }
+        })
+    }
+
+    /// Get current module name (simple name, not qualified)
+    pub fn current_module_name(&self) -> Option<String> {
+        self.walk_scopes().find_map(|scope| {
+            if let ScopeKind::Module { name } = &scope.kind {
+                Some(name.clone())
+            } else {
+                None
+            }
+        })
+    }
+
+    /// Get current fully qualified name by traversing all parent class/module scopes
+    ///
+    /// For example, in:
+    /// ```ruby
+    /// module Api
+    ///   module V1
+    ///     class User
+    ///       def greet; end
+    ///     end
+    ///   end
+    /// end
+    /// ```
+    /// When inside `greet`, this returns `Some("Api::V1::User")`
+    pub fn current_qualified_name(&self) -> Option<String> {
+        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;
+        }
+
+        // Reverse to get from outermost to innermost
+        path_segments.reverse();
+        Some(path_segments.join("::"))
+    }
+
+    /// Get current method name from nearest enclosing method scope
+    pub fn current_method_name(&self) -> Option<String> {
+        self.walk_scopes().find_map(|scope| {
+            if let ScopeKind::Method { name, .. } = &scope.kind {
+                Some(name.clone())
+            } else {
+                None
+            }
+        })
+    }
+
+    /// Get superclass name from nearest enclosing class scope
+    pub fn current_superclass(&self) -> Option<String> {
+        self.walk_scopes().find_map(|scope| {
+            if let ScopeKind::Class { superclass, .. } = &scope.kind {
+                superclass.clone()
+            } else {
+                None
+            }
+        })
+    }
+
+    /// Get return_vertex from the nearest enclosing method 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
+            }
+        })
+    }
+
+    /// Lookup instance variable in enclosing module scope
+    pub fn lookup_instance_var_in_module(&self, name: &str) -> Option<VertexId> {
+        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 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);
+            }
+        }
+    }
+}

data/{rust → core}/src/env/vertex_manager.rs

@@ -119,76 +119,3 @@ impl VertexManager {
         lines.join("\n")
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_new_vertex() {
-        let mut manager = VertexManager::new();
-
-        let v1 = manager.new_vertex();
-        let v2 = manager.new_vertex();
-
-        assert_eq!(v1.0, 0);
-        assert_eq!(v2.0, 1);
-        assert!(manager.get_vertex(v1).is_some());
-        assert!(manager.get_vertex(v2).is_some());
-    }
-
-    #[test]
-    fn test_new_source() {
-        let mut manager = VertexManager::new();
-
-        let s1 = manager.new_source(Type::string());
-        let s2 = manager.new_source(Type::integer());
-
-        assert_eq!(manager.get_source(s1).unwrap().ty.show(), "String");
-        assert_eq!(manager.get_source(s2).unwrap().ty.show(), "Integer");
-    }
-
-    #[test]
-    fn test_edge_propagation() {
-        let mut manager = VertexManager::new();
-
-        let src = manager.new_source(Type::string());
-        let vtx = manager.new_vertex();
-
-        manager.add_edge(src, vtx);
-
-        assert_eq!(manager.get_vertex(vtx).unwrap().show(), "String");
-    }
-
-    #[test]
-    fn test_chain_propagation() {
-        let mut manager = VertexManager::new();
-
-        let src = manager.new_source(Type::string());
-        let v1 = manager.new_vertex();
-        let v2 = manager.new_vertex();
-
-        manager.add_edge(src, v1);
-        manager.add_edge(v1, v2);
-
-        assert_eq!(manager.get_vertex(v1).unwrap().show(), "String");
-        assert_eq!(manager.get_vertex(v2).unwrap().show(), "String");
-    }
-
-    #[test]
-    fn test_union_propagation() {
-        let mut manager = VertexManager::new();
-
-        let src1 = manager.new_source(Type::string());
-        let src2 = manager.new_source(Type::integer());
-        let vtx = manager.new_vertex();
-
-        manager.add_edge(src1, vtx);
-        manager.add_edge(src2, vtx);
-
-        assert_eq!(
-            manager.get_vertex(vtx).unwrap().show(),
-            "(Integer | String)"
-        );
-    }
-}