method-ray 0.1.1

data/rust/src/env/scope.rs

@@ -0,0 +1,330 @@
+use crate::graph::VertexId;
+use std::collections::HashMap;
+
+/// スコープID
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct ScopeId(pub usize);
+
+/// スコープの種類
+#[derive(Debug, Clone)]
+#[allow(dead_code)]
+pub enum ScopeKind {
+    TopLevel,
+    Class {
+        name: String,
+        superclass: Option<String>,
+    },
+    Module {
+        name: String,
+    },
+    Method {
+        name: String,
+        receiver_type: Option<String>, // レシーバーのクラス名
+    },
+    Block,
+}
+
+/// スコープ情報
+#[derive(Debug, Clone)]
+#[allow(dead_code)]
+pub struct Scope {
+    pub id: ScopeId,
+    pub kind: ScopeKind,
+    pub parent: Option<ScopeId>,
+
+    /// ローカル変数
+    pub local_vars: HashMap<String, VertexId>,
+
+    /// インスタンス変数（クラス/メソッドスコープのみ）
+    pub instance_vars: HashMap<String, VertexId>,
+
+    /// クラス変数（クラススコープのみ）
+    pub class_vars: HashMap<String, VertexId>,
+}
+
+#[allow(dead_code)]
+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(),
+        }
+    }
+
+    /// ローカル変数を追加
+    pub fn set_local_var(&mut self, name: String, vtx: VertexId) {
+        self.local_vars.insert(name, vtx);
+    }
+
+    /// ローカル変数を取得
+    pub fn get_local_var(&self, name: &str) -> Option<VertexId> {
+        self.local_vars.get(name).copied()
+    }
+
+    /// インスタンス変数を追加
+    pub fn set_instance_var(&mut self, name: String, vtx: VertexId) {
+        self.instance_vars.insert(name, vtx);
+    }
+
+    /// インスタンス変数を取得
+    pub fn get_instance_var(&self, name: &str) -> Option<VertexId> {
+        self.instance_vars.get(name).copied()
+    }
+}
+
+/// スコープマネージャー
+#[derive(Debug)]
+pub struct ScopeManager {
+    scopes: HashMap<ScopeId, Scope>,
+    next_id: usize,
+    current_scope: ScopeId,
+}
+
+#[allow(dead_code)]
+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),
+        }
+    }
+
+    /// 新しいスコープを作成
+    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
+    }
+
+    /// スコープに入る
+    pub fn enter_scope(&mut self, scope_id: ScopeId) {
+        self.current_scope = scope_id;
+    }
+
+    /// スコープから出る
+    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;
+            }
+        }
+    }
+
+    /// 現在のスコープを取得
+    pub fn current_scope(&self) -> &Scope {
+        self.scopes.get(&self.current_scope).unwrap()
+    }
+
+    /// 現在のスコープを可変で取得
+    pub fn current_scope_mut(&mut self) -> &mut Scope {
+        self.scopes.get_mut(&self.current_scope).unwrap()
+    }
+
+    /// スコープを取得
+    pub fn get_scope(&self, id: ScopeId) -> Option<&Scope> {
+        self.scopes.get(&id)
+    }
+
+    /// スコープを可変で取得
+    pub fn get_scope_mut(&mut self, id: ScopeId) -> Option<&mut Scope> {
+        self.scopes.get_mut(&id)
+    }
+
+    /// 変数を現在のスコープまたは親スコープから検索
+    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;
+            }
+        }
+
+        None
+    }
+
+    /// インスタンス変数を現在のクラススコープから検索
+    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) {
+                // クラススコープまで遡る
+                match &scope.kind {
+                    ScopeKind::Class { .. } => {
+                        return scope.get_instance_var(name);
+                    }
+                    _ => {
+                        current = scope.parent;
+                    }
+                }
+            } else {
+                break;
+            }
+        }
+
+        None
+    }
+
+    /// インスタンス変数を現在のクラススコープに設定
+    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) {
+                // クラススコープを見つけたら設定
+                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;
+            }
+        }
+    }
+
+    /// 現在のクラス名を取得
+    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;
+            } else {
+                break;
+            }
+        }
+
+        None
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_scope_manager_creation() {
+        let sm = ScopeManager::new();
+        assert_eq!(sm.current_scope().id, ScopeId(0));
+        assert!(matches!(sm.current_scope().kind, ScopeKind::TopLevel));
+    }
+
+    #[test]
+    fn test_scope_manager_new_scope() {
+        let mut sm = ScopeManager::new();
+
+        let class_id = sm.new_scope(ScopeKind::Class {
+            name: "User".to_string(),
+            superclass: None,
+        });
+
+        assert_eq!(class_id, ScopeId(1));
+        assert_eq!(sm.current_scope().id, ScopeId(0)); // Still in top-level
+    }
+
+    #[test]
+    fn test_scope_manager_enter_exit() {
+        let mut sm = ScopeManager::new();
+
+        let class_id = sm.new_scope(ScopeKind::Class {
+            name: "User".to_string(),
+            superclass: None,
+        });
+
+        sm.enter_scope(class_id);
+        assert_eq!(sm.current_scope().id, ScopeId(1));
+
+        sm.exit_scope();
+        assert_eq!(sm.current_scope().id, ScopeId(0));
+    }
+
+    #[test]
+    fn test_scope_manager_local_var() {
+        let mut sm = ScopeManager::new();
+
+        sm.current_scope_mut()
+            .set_local_var("x".to_string(), VertexId(10));
+
+        assert_eq!(sm.lookup_var("x"), Some(VertexId(10)));
+        assert_eq!(sm.lookup_var("y"), None);
+    }
+
+    #[test]
+    fn test_scope_manager_nested_lookup() {
+        let mut sm = ScopeManager::new();
+
+        // Top level: x = 10
+        sm.current_scope_mut()
+            .set_local_var("x".to_string(), VertexId(10));
+
+        // Enter class
+        let class_id = sm.new_scope(ScopeKind::Class {
+            name: "User".to_string(),
+            superclass: None,
+        });
+        sm.enter_scope(class_id);
+
+        // Class level: y = 20
+        sm.current_scope_mut()
+            .set_local_var("y".to_string(), VertexId(20));
+
+        // Can lookup both x (from parent) and y (from current)
+        assert_eq!(sm.lookup_var("x"), Some(VertexId(10)));
+        assert_eq!(sm.lookup_var("y"), Some(VertexId(20)));
+    }
+
+    #[test]
+    fn test_scope_manager_current_class_name() {
+        let mut sm = ScopeManager::new();
+
+        assert_eq!(sm.current_class_name(), None);
+
+        let class_id = sm.new_scope(ScopeKind::Class {
+            name: "User".to_string(),
+            superclass: None,
+        });
+        sm.enter_scope(class_id);
+
+        assert_eq!(sm.current_class_name(), Some("User".to_string()));
+
+        // Enter method within class
+        let method_id = sm.new_scope(ScopeKind::Method {
+            name: "test".to_string(),
+            receiver_type: None,
+        });
+        sm.enter_scope(method_id);
+
+        // Should still find parent class name
+        assert_eq!(sm.current_class_name(), Some("User".to_string()));
+    }
+}

data/rust/src/env/type_error.rs

@@ -0,0 +1,23 @@
+//! Type error definitions for diagnostic reporting
+
+use crate::source_map::SourceLocation;
+use crate::types::Type;
+
+/// Type error information for diagnostic reporting
+#[derive(Debug, Clone)]
+pub struct TypeError {
+    pub receiver_type: Type,
+    pub method_name: String,
+    pub location: Option<SourceLocation>,
+}
+
+impl TypeError {
+    /// Create a new type error
+    pub fn new(receiver_type: Type, method_name: String, location: Option<SourceLocation>) -> Self {
+        Self {
+            receiver_type,
+            method_name,
+            location,
+        }
+    }
+}

data/rust/src/env/vertex_manager.rs

@@ -0,0 +1,195 @@
+//! Vertex and Source management
+//!
+//! Handles creation, storage, and type propagation for vertices and sources.
+
+use crate::graph::{Source, Vertex, VertexId};
+use crate::types::Type;
+use std::collections::HashMap;
+
+/// Manages vertices and sources in the type graph
+#[derive(Debug, Default)]
+pub struct VertexManager {
+    /// All vertices in the graph
+    pub vertices: HashMap<VertexId, Vertex>,
+    /// All sources (fixed-type nodes) in the graph
+    pub sources: HashMap<VertexId, Source>,
+    /// Next vertex ID to allocate
+    next_vertex_id: usize,
+}
+
+#[allow(dead_code)]
+impl VertexManager {
+    /// Create a new empty vertex manager
+    pub fn new() -> Self {
+        Self {
+            vertices: HashMap::new(),
+            sources: HashMap::new(),
+            next_vertex_id: 0,
+        }
+    }
+
+    /// Create a new vertex and return its ID
+    pub fn new_vertex(&mut self) -> VertexId {
+        let id = VertexId(self.next_vertex_id);
+        self.next_vertex_id += 1;
+        self.vertices.insert(id, Vertex::new());
+        id
+    }
+
+    /// Create a new source with a fixed type
+    pub fn new_source(&mut self, ty: Type) -> VertexId {
+        let id = VertexId(self.next_vertex_id);
+        self.next_vertex_id += 1;
+        self.sources.insert(id, Source::new(ty));
+        id
+    }
+
+    /// Get a vertex by ID
+    pub fn get_vertex(&self, id: VertexId) -> Option<&Vertex> {
+        self.vertices.get(&id)
+    }
+
+    /// Get a vertex mutably by ID
+    pub fn get_vertex_mut(&mut self, id: VertexId) -> Option<&mut Vertex> {
+        self.vertices.get_mut(&id)
+    }
+
+    /// Get a source by ID
+    pub fn get_source(&self, id: VertexId) -> Option<&Source> {
+        self.sources.get(&id)
+    }
+
+    /// Add an edge between two vertices and propagate types
+    pub fn add_edge(&mut self, src: VertexId, dst: VertexId) {
+        // Add edge from src to dst
+        if let Some(src_vtx) = self.vertices.get_mut(&src) {
+            src_vtx.add_next(dst);
+        }
+
+        // Propagate type
+        self.propagate_from(src, dst);
+    }
+
+    /// Get types from a vertex or source
+    fn get_types(&self, id: VertexId) -> Vec<Type> {
+        if let Some(vtx) = self.vertices.get(&id) {
+            vtx.types.keys().cloned().collect()
+        } else if let Some(src) = self.sources.get(&id) {
+            vec![src.ty.clone()]
+        } else {
+            vec![]
+        }
+    }
+
+    /// Propagate types from src to dst
+    fn propagate_from(&mut self, src: VertexId, dst: VertexId) {
+        let types = self.get_types(src);
+        if !types.is_empty() {
+            self.propagate_types(src, dst, types);
+        }
+    }
+
+    /// Recursively propagate types through the graph
+    fn propagate_types(&mut self, src_id: VertexId, dst_id: VertexId, types: Vec<Type>) {
+        // Add type only if dst is a Vertex (not a Source)
+        let next_propagations = if let Some(dst_vtx) = self.vertices.get_mut(&dst_id) {
+            dst_vtx.on_type_added(src_id, types)
+        } else {
+            // If dst is a Source, do nothing (fixed type)
+            return;
+        };
+
+        // Recursively propagate to next vertices
+        for (next_id, next_types) in next_propagations {
+            self.propagate_types(dst_id, next_id, next_types);
+        }
+    }
+
+    /// Display all vertices and sources for debugging
+    pub fn show_all(&self) -> String {
+        let mut lines = Vec::new();
+
+        for (id, vtx) in &self.vertices {
+            lines.push(format!("Vertex {}: {}", id.0, vtx.show()));
+        }
+
+        for (id, src) in &self.sources {
+            lines.push(format!("Source {}: {}", id.0, src.ty.show()));
+        }
+
+        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)"
+        );
+    }
+}

data/rust/src/graph/box.rs

@@ -0,0 +1,157 @@
+use crate::env::GlobalEnv;
+use crate::graph::change_set::ChangeSet;
+use crate::graph::vertex::VertexId;
+use crate::source_map::SourceLocation;
+use crate::types::Type;
+
+/// Unique ID for Box
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+pub struct BoxId(pub usize);
+
+/// Box trait: represents constraints such as method calls
+#[allow(dead_code)]
+pub trait BoxTrait: Send + Sync {
+    fn id(&self) -> BoxId;
+    fn run(&mut self, genv: &mut GlobalEnv, changes: &mut ChangeSet);
+    fn ret(&self) -> VertexId;
+}
+
+/// Box representing a method call
+#[allow(dead_code)]
+pub struct MethodCallBox {
+    id: BoxId,
+    recv: VertexId,
+    method_name: String,
+    ret: VertexId,
+    location: Option<SourceLocation>, // Source code location
+}
+
+impl MethodCallBox {
+    pub fn new(
+        id: BoxId,
+        recv: VertexId,
+        method_name: String,
+        ret: VertexId,
+        location: Option<SourceLocation>,
+    ) -> Self {
+        Self {
+            id,
+            recv,
+            method_name,
+            ret,
+            location,
+        }
+    }
+}
+
+impl BoxTrait for MethodCallBox {
+    fn id(&self) -> BoxId {
+        self.id
+    }
+
+    fn ret(&self) -> VertexId {
+        self.ret
+    }
+
+    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
+            return;
+        };
+
+        for recv_ty in recv_types {
+            // Resolve method
+            if let Some(method_info) = genv.resolve_method(&recv_ty, &self.method_name) {
+                // Create return type as Source
+                let ret_src_id = genv.new_source(method_info.return_type.clone());
+
+                // Add edge to return value
+                changes.add_edge(ret_src_id, self.ret);
+            } else {
+                // Record type error for diagnostic reporting
+                genv.record_type_error(
+                    recv_ty.clone(),
+                    self.method_name.clone(),
+                    self.location.clone(),
+                );
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::env::GlobalEnv;
+    use crate::types::Type;
+
+    #[test]
+    fn test_method_call_box() {
+        let mut genv = GlobalEnv::new();
+
+        // Register String#upcase
+        genv.register_builtin_method(Type::string(), "upcase", Type::string());
+
+        // x = "hello" (Source<String> -> Vertex)
+        let x_vtx = genv.new_vertex();
+        let str_src = genv.new_source(Type::string());
+        genv.add_edge(str_src, x_vtx);
+
+        // x.upcase
+        let ret_vtx = genv.new_vertex();
+        let box_id = BoxId(0);
+        let mut call_box = MethodCallBox::new(
+            box_id,
+            x_vtx,
+            "upcase".to_string(),
+            ret_vtx,
+            None, // No location in test
+        );
+
+        // Execute Box
+        let mut changes = ChangeSet::new();
+        call_box.run(&mut genv, &mut changes);
+        genv.apply_changes(changes);
+
+        // Check return type
+        let ret_vertex = genv.get_vertex(ret_vtx).unwrap();
+        assert_eq!(ret_vertex.show(), "String");
+    }
+
+    #[test]
+    fn test_method_call_box_undefined() {
+        let mut genv = GlobalEnv::new();
+
+        // Don't register method
+
+        let x_vtx = genv.new_vertex();
+        let str_src = genv.new_source(Type::string());
+        genv.add_edge(str_src, x_vtx);
+
+        // x.unknown_method (undefined)
+        let ret_vtx = genv.new_vertex();
+        let box_id = BoxId(0);
+        let mut call_box = MethodCallBox::new(
+            box_id,
+            x_vtx,
+            "unknown_method".to_string(),
+            ret_vtx,
+            None, // No location in test
+        );
+
+        let mut changes = ChangeSet::new();
+        call_box.run(&mut genv, &mut changes);
+        genv.apply_changes(changes);
+
+        // Return value is untyped
+        let ret_vertex = genv.get_vertex(ret_vtx).unwrap();
+        assert_eq!(ret_vertex.show(), "untyped");
+    }
+}