method-ray 0.1.9 → 0.1.10

data/core/src/analyzer/definitions.rs

@@ -27,6 +27,17 @@ pub(crate) fn process_class_node(
 ) -> Option<VertexId> {
     let class_name = extract_class_name(class_node);
     let superclass = class_node.superclass().and_then(|sup| extract_constant_path(&sup));
+
+    // Warn if superclass is a dynamic expression (not a constant path)
+    // TODO: Replace eprintln! with structured diagnostic (record_type_error or warning)
+    //       so this is visible in LSP mode and includes source location.
+    if class_node.superclass().is_some() && superclass.is_none() {
+        eprintln!(
+            "[methodray] warning: dynamic superclass expression in class {}; inheritance will be ignored",
+            class_name
+        );
+    }
+
     install_class(genv, class_name, superclass.as_deref());
 
     if let Some(body) = class_node.body() {
@@ -192,529 +203,3 @@ pub(crate) fn extract_constant_path(node: &Node) -> Option<String> {
 
     None
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::graph::ChangeSet;
-    use crate::parser::ParseSession;
-    use crate::types::Type;
-
-    #[test]
-    fn test_enter_exit_class_scope() {
-        let mut genv = GlobalEnv::new();
-
-        install_class(&mut genv, "User".to_string(), None);
-        assert_eq!(
-            genv.scope_manager.current_class_name(),
-            Some("User".to_string())
-        );
-
-        exit_scope(&mut genv);
-        assert_eq!(genv.scope_manager.current_class_name(), None);
-    }
-
-    #[test]
-    fn test_enter_exit_module_scope() {
-        let mut genv = GlobalEnv::new();
-
-        install_module(&mut genv, "Utils".to_string());
-        assert_eq!(
-            genv.scope_manager.current_module_name(),
-            Some("Utils".to_string())
-        );
-
-        exit_scope(&mut genv);
-        assert_eq!(genv.scope_manager.current_module_name(), None);
-    }
-
-    #[test]
-    fn test_nested_method_scope() {
-        let mut genv = GlobalEnv::new();
-
-        install_class(&mut genv, "User".to_string(), None);
-        install_method(&mut genv, "greet".to_string());
-
-        // Still in User class context
-        assert_eq!(
-            genv.scope_manager.current_class_name(),
-            Some("User".to_string())
-        );
-
-        exit_scope(&mut genv); // exit method
-        exit_scope(&mut genv); // exit class
-
-        assert_eq!(genv.scope_manager.current_class_name(), None);
-    }
-
-    #[test]
-    fn test_method_in_module() {
-        let mut genv = GlobalEnv::new();
-
-        install_module(&mut genv, "Helpers".to_string());
-        install_method(&mut genv, "format".to_string());
-
-        // Should find module context from within method
-        assert_eq!(
-            genv.scope_manager.current_module_name(),
-            Some("Helpers".to_string())
-        );
-
-        exit_scope(&mut genv); // exit method
-        exit_scope(&mut genv); // exit module
-
-        assert_eq!(genv.scope_manager.current_module_name(), None);
-    }
-
-    #[test]
-    fn test_extract_simple_class_name() {
-        let source = "class User; end";
-        let session = ParseSession::new();
-        let parse_result = session.parse_source(source, "test.rb").unwrap();
-        let root = parse_result.node();
-        let program = root.as_program_node().unwrap();
-        let stmt = program.statements().body().first().unwrap();
-        let class_node = stmt.as_class_node().unwrap();
-
-        let name = extract_class_name(&class_node);
-        assert_eq!(name, "User");
-    }
-
-    #[test]
-    fn test_extract_qualified_class_name() {
-        let source = "class Api::User; end";
-        let session = ParseSession::new();
-        let parse_result = session.parse_source(source, "test.rb").unwrap();
-        let root = parse_result.node();
-        let program = root.as_program_node().unwrap();
-        let stmt = program.statements().body().first().unwrap();
-        let class_node = stmt.as_class_node().unwrap();
-
-        let name = extract_class_name(&class_node);
-        assert_eq!(name, "Api::User");
-    }
-
-    #[test]
-    fn test_extract_deeply_qualified_class_name() {
-        let source = "class Api::V1::Admin::User; end";
-        let session = ParseSession::new();
-        let parse_result = session.parse_source(source, "test.rb").unwrap();
-        let root = parse_result.node();
-        let program = root.as_program_node().unwrap();
-        let stmt = program.statements().body().first().unwrap();
-        let class_node = stmt.as_class_node().unwrap();
-
-        let name = extract_class_name(&class_node);
-        assert_eq!(name, "Api::V1::Admin::User");
-    }
-
-    #[test]
-    fn test_extract_simple_module_name() {
-        let source = "module Utils; end";
-        let session = ParseSession::new();
-        let parse_result = session.parse_source(source, "test.rb").unwrap();
-        let root = parse_result.node();
-        let program = root.as_program_node().unwrap();
-        let stmt = program.statements().body().first().unwrap();
-        let module_node = stmt.as_module_node().unwrap();
-
-        let name = extract_module_name(&module_node);
-        assert_eq!(name, "Utils");
-    }
-
-    #[test]
-    fn test_extract_qualified_module_name() {
-        let source = "module Api::V1; end";
-        let session = ParseSession::new();
-        let parse_result = session.parse_source(source, "test.rb").unwrap();
-        let root = parse_result.node();
-        let program = root.as_program_node().unwrap();
-        let stmt = program.statements().body().first().unwrap();
-        let module_node = stmt.as_module_node().unwrap();
-
-        let name = extract_module_name(&module_node);
-        assert_eq!(name, "Api::V1");
-    }
-
-    #[test]
-    fn test_process_def_node_registers_user_method() {
-        let source = "class User; def name; \"Alice\"; end; end";
-        let session = ParseSession::new();
-        let parse_result = session.parse_source(source, "test.rb").unwrap();
-        let root = parse_result.node();
-        let program = root.as_program_node().unwrap();
-
-        let mut genv = GlobalEnv::new();
-        let mut lenv = LocalEnv::new();
-        let mut changes = ChangeSet::new();
-
-        let stmt = program.statements().body().first().unwrap();
-        let class_node = stmt.as_class_node().unwrap();
-        process_class_node(&mut genv, &mut lenv, &mut changes, source, &class_node);
-
-        // User#name should be registered as a user-defined method
-        let info = genv
-            .resolve_method(&Type::instance("User"), "name")
-            .expect("User#name should be registered");
-        assert!(info.return_vertex.is_some());
-    }
-
-    #[test]
-    fn test_qualified_name_method_registration() {
-        let source = r#"
-module Api
-  module V1
-    class User
-      def name
-        "Alice"
-      end
-    end
-  end
-end
-"#;
-        let session = ParseSession::new();
-        let parse_result = session.parse_source(source, "test.rb").unwrap();
-        let root = parse_result.node();
-        let program = root.as_program_node().unwrap();
-
-        let mut genv = GlobalEnv::new();
-        let mut lenv = LocalEnv::new();
-        let mut changes = ChangeSet::new();
-
-        for stmt in &program.statements().body() {
-            crate::analyzer::install::install_node(&mut genv, &mut lenv, &mut changes, source, &stmt);
-        }
-
-        // Method should be registered with qualified name "Api::V1::User"
-        let info = genv
-            .resolve_method(&Type::instance("Api::V1::User"), "name")
-            .expect("Api::V1::User#name should be registered");
-        assert!(info.return_vertex.is_some());
-
-        // Should NOT be registered with simple name "User"
-        assert!(
-            genv.resolve_method(&Type::instance("User"), "name").is_none(),
-            "User#name should not exist — method should be registered under qualified name"
-        );
-    }
-
-    #[test]
-    fn test_same_class_name_different_namespace() {
-        let source = r#"
-module Api
-  class User
-    def name
-      "api_user"
-    end
-  end
-end
-
-module Admin
-  class User
-    def name
-      "admin_user"
-    end
-  end
-end
-"#;
-        let session = ParseSession::new();
-        let parse_result = session.parse_source(source, "test.rb").unwrap();
-        let root = parse_result.node();
-        let program = root.as_program_node().unwrap();
-
-        let mut genv = GlobalEnv::new();
-        let mut lenv = LocalEnv::new();
-        let mut changes = ChangeSet::new();
-
-        for stmt in &program.statements().body() {
-            crate::analyzer::install::install_node(&mut genv, &mut lenv, &mut changes, source, &stmt);
-        }
-
-        // Both should be registered separately
-        let api_info = genv
-            .resolve_method(&Type::instance("Api::User"), "name")
-            .expect("Api::User#name should be registered");
-        assert!(api_info.return_vertex.is_some());
-
-        let admin_info = genv
-            .resolve_method(&Type::instance("Admin::User"), "name")
-            .expect("Admin::User#name should be registered");
-        assert!(admin_info.return_vertex.is_some());
-
-        // Simple "User" should not resolve
-        assert!(
-            genv.resolve_method(&Type::instance("User"), "name").is_none(),
-            "User#name should not exist — both are under qualified names"
-        );
-    }
-
-    #[test]
-    fn test_class_method_registration() {
-        let source = r#"
-class User
-  def self.create
-    "created"
-  end
-end
-"#;
-        let session = ParseSession::new();
-        let parse_result = session.parse_source(source, "test.rb").unwrap();
-        let root = parse_result.node();
-        let program = root.as_program_node().unwrap();
-
-        let mut genv = GlobalEnv::new();
-        let mut lenv = LocalEnv::new();
-        let mut changes = ChangeSet::new();
-
-        for stmt in &program.statements().body() {
-            crate::analyzer::install::install_node(&mut genv, &mut lenv, &mut changes, source, &stmt);
-        }
-
-        // def self.create should be registered as singleton method
-        let info = genv
-            .resolve_method(&Type::singleton("User"), "create")
-            .expect("User.create should be registered as singleton method");
-        assert!(info.return_vertex.is_some());
-    }
-
-    #[test]
-    fn test_class_method_with_params() {
-        let source = r#"
-class User
-  def self.find(id)
-    "user"
-  end
-end
-"#;
-        let session = ParseSession::new();
-        let parse_result = session.parse_source(source, "test.rb").unwrap();
-        let root = parse_result.node();
-        let program = root.as_program_node().unwrap();
-
-        let mut genv = GlobalEnv::new();
-        let mut lenv = LocalEnv::new();
-        let mut changes = ChangeSet::new();
-
-        for stmt in &program.statements().body() {
-            crate::analyzer::install::install_node(&mut genv, &mut lenv, &mut changes, source, &stmt);
-        }
-
-        let info = genv
-            .resolve_method(&Type::singleton("User"), "find")
-            .expect("User.find should be registered");
-        assert!(info.return_vertex.is_some());
-        assert_eq!(info.param_vertices.as_ref().unwrap().len(), 1);
-    }
-
-    #[test]
-    fn test_class_method_in_qualified_namespace() {
-        let source = r#"
-module Api
-  class User
-    def self.create
-      "created"
-    end
-  end
-end
-"#;
-        let session = ParseSession::new();
-        let parse_result = session.parse_source(source, "test.rb").unwrap();
-        let root = parse_result.node();
-        let program = root.as_program_node().unwrap();
-
-        let mut genv = GlobalEnv::new();
-        let mut lenv = LocalEnv::new();
-        let mut changes = ChangeSet::new();
-
-        for stmt in &program.statements().body() {
-            crate::analyzer::install::install_node(&mut genv, &mut lenv, &mut changes, source, &stmt);
-        }
-
-        let info = genv
-            .resolve_method(&Type::singleton("Api::User"), "create")
-            .expect("Api::User.create should be registered");
-        assert!(info.return_vertex.is_some());
-    }
-
-    #[test]
-    fn test_class_method_not_registered_as_instance() {
-        let source = r#"
-class User
-  def self.create
-    "created"
-  end
-end
-"#;
-        let session = ParseSession::new();
-        let parse_result = session.parse_source(source, "test.rb").unwrap();
-        let root = parse_result.node();
-        let program = root.as_program_node().unwrap();
-
-        let mut genv = GlobalEnv::new();
-        let mut lenv = LocalEnv::new();
-        let mut changes = ChangeSet::new();
-
-        for stmt in &program.statements().body() {
-            crate::analyzer::install::install_node(&mut genv, &mut lenv, &mut changes, source, &stmt);
-        }
-
-        // def self.create should NOT be registered as instance method
-        assert!(
-            genv.resolve_method(&Type::instance("User"), "create").is_none(),
-            "User#create should not exist — it's a class method"
-        );
-    }
-
-    #[test]
-    fn test_non_self_receiver_not_treated_as_class_method() {
-        let source = r#"
-class User
-  def other.foo
-    "test"
-  end
-end
-"#;
-        let session = ParseSession::new();
-        let parse_result = session.parse_source(source, "test.rb").unwrap();
-        let root = parse_result.node();
-        let program = root.as_program_node().unwrap();
-
-        let mut genv = GlobalEnv::new();
-        let mut lenv = LocalEnv::new();
-        let mut changes = ChangeSet::new();
-
-        for stmt in &program.statements().body() {
-            crate::analyzer::install::install_node(&mut genv, &mut lenv, &mut changes, source, &stmt);
-        }
-
-        // def other.foo should NOT be registered as singleton method
-        assert!(
-            genv.resolve_method(&Type::singleton("User"), "foo").is_none(),
-            "User.foo should not exist — receiver is not self"
-        );
-    }
-
-    #[test]
-    fn test_class_method_return_type_inference() {
-        let source = r#"
-class User
-  def self.create
-    "created"
-  end
-end
-"#;
-        let session = ParseSession::new();
-        let parse_result = session.parse_source(source, "test.rb").unwrap();
-        let root = parse_result.node();
-        let program = root.as_program_node().unwrap();
-
-        let mut genv = GlobalEnv::new();
-        let mut lenv = LocalEnv::new();
-        let mut changes = ChangeSet::new();
-
-        for stmt in &program.statements().body() {
-            crate::analyzer::install::install_node(&mut genv, &mut lenv, &mut changes, source, &stmt);
-        }
-
-        let info = genv
-            .resolve_method(&Type::singleton("User"), "create")
-            .expect("User.create should be registered");
-        let ret_vtx = info.return_vertex.expect("should have return vertex");
-
-        // Run solver to propagate types
-        genv.apply_changes(changes);
-        genv.run_all();
-
-        let vertex = genv.get_vertex(ret_vtx).or_else(|| {
-            // return vertex might be a source
-            None
-        });
-        if let Some(v) = vertex {
-            assert_eq!(v.show(), "String");
-        } else {
-            // Check if it's a source
-            let src = genv.get_source(ret_vtx).expect("should have source or vertex");
-            assert_eq!(src.ty, Type::string());
-        }
-    }
-
-    #[test]
-    fn test_class_method_in_reopened_class() {
-        let source = r#"
-class User
-  def self.create
-    "created"
-  end
-end
-
-class User
-  def self.destroy
-    "destroyed"
-  end
-end
-"#;
-        let session = ParseSession::new();
-        let parse_result = session.parse_source(source, "test.rb").unwrap();
-        let root = parse_result.node();
-        let program = root.as_program_node().unwrap();
-
-        let mut genv = GlobalEnv::new();
-        let mut lenv = LocalEnv::new();
-        let mut changes = ChangeSet::new();
-
-        for stmt in &program.statements().body() {
-            crate::analyzer::install::install_node(&mut genv, &mut lenv, &mut changes, source, &stmt);
-        }
-
-        // Both class methods should be registered
-        assert!(
-            genv.resolve_method(&Type::singleton("User"), "create").is_some(),
-            "User.create should be registered"
-        );
-        assert!(
-            genv.resolve_method(&Type::singleton("User"), "destroy").is_some(),
-            "User.destroy should be registered"
-        );
-    }
-
-    #[test]
-    fn test_class_method_param_type_propagation() {
-        let source = r#"
-class User
-  def self.find(id)
-    id
-  end
-end
-
-User.find(42)
-"#;
-        let session = ParseSession::new();
-        let parse_result = session.parse_source(source, "test.rb").unwrap();
-        let root = parse_result.node();
-        let program = root.as_program_node().unwrap();
-
-        let mut genv = GlobalEnv::new();
-        let mut lenv = LocalEnv::new();
-        let mut changes = ChangeSet::new();
-
-        for stmt in &program.statements().body() {
-            crate::analyzer::install::install_node(&mut genv, &mut lenv, &mut changes, source, &stmt);
-        }
-
-        let info = genv
-            .resolve_method(&Type::singleton("User"), "find")
-            .expect("User.find should be registered");
-        let param_vtxs = info.param_vertices.as_ref().expect("should have param vertices");
-        assert_eq!(param_vtxs.len(), 1);
-
-        let param_vtx = param_vtxs[0];
-
-        // Run solver to propagate argument types
-        genv.apply_changes(changes);
-        genv.run_all();
-
-        // Parameter should have Integer type propagated from call site
-        let vertex = genv.get_vertex(param_vtx).expect("param vertex should exist");
-        assert_eq!(vertex.show(), "Integer");
-    }
-}