rubydex 0.3.0 → 0.4.1

data/rust/rubydex/src/resolution_tests.rs

@@ -8,7 +8,7 @@ use crate::{
     assert_declaration_exists, assert_declaration_kind_eq, assert_declaration_references_count_eq, assert_descendants,
     assert_diagnostics_eq, assert_instance_variables_eq, assert_members_eq, assert_no_constant_alias_target,
     assert_no_diagnostics, assert_no_members, assert_owner_eq, assert_singleton_class_eq,
-    diagnostic::Rule,
+    diagnostic::{Rule, Severity},
     model::{declaration::Ancestors, ids::DeclarationId, name::NameRef},
     test_utils::GraphTest,
 };
@@ -1494,6 +1494,43 @@ mod include_tests {
         assert_descendants!(context, "Bar", ["Baz"]);
         assert_descendants!(context, "Foo", ["Bar", "Baz"]);
     }
+
+    #[test]
+    fn unresolved_include_followed_by_resolved_include_stays_partial() {
+        let mut context = graph_test();
+        context.index_uri("file:///foo.rb", {
+            r"
+            module M
+            end
+
+            class C
+              include Missing
+              include M
+            end
+            "
+        });
+        context.resolve();
+
+        assert_ancestors_eq!(
+            context,
+            "C",
+            ["C", "M", Partial("Missing"), "Object", "Kernel", "BasicObject"]
+        );
+        assert!(
+            matches!(
+                context
+                    .graph()
+                    .declarations()
+                    .get(&DeclarationId::from("C"))
+                    .unwrap()
+                    .as_namespace()
+                    .unwrap()
+                    .ancestors(),
+                Ancestors::Partial(_)
+            ),
+            "C should have a partial chain: the `Missing` include never resolves"
+        );
+    }
 }
 
 mod prepend_tests {
@@ -2132,6 +2169,30 @@ mod object_ancestors_tests {
         assert_constant_reference_to!(context, "Kernel::FOUND_ME", "file:///foo.rb:11:3-11:11");
         assert_constant_reference_unresolved!(context, "FOUND_ME", "file:///foo.rb:14:6-14:14");
     }
+
+    #[test]
+    fn object_inherited_constant_inside_module_reordered() {
+        let mut context = graph_test();
+        context.index_uri("file:///foo.rb", {
+            r"
+            module Foo
+              # Accessible via Object inheritance
+              FOUND_ME
+            end
+
+            module Kernel
+              FOUND_ME = true
+            end
+
+            class Object
+              include Kernel
+            end
+            "
+        });
+        context.resolve();
+
+        assert_constant_reference_to!(context, "Kernel::FOUND_ME", "file:///foo.rb:3:3-3:11");
+    }
 }
 
 mod singleton_ancestors_tests {
@@ -3033,7 +3094,7 @@ mod variable_tests {
 
         assert_diagnostics_eq!(
             &context,
-            ["dynamic-singleton-definition: Dynamic receiver for singleton method definition (2:3-4:6)",]
+            ["DynamicSingletonDefinition: Dynamic receiver for singleton method definition (2:3-4:6)",]
         );
 
         // Instance variable in method with unresolved receiver should not create a declaration
@@ -3922,6 +3983,41 @@ mod todo_tests {
         assert_members_eq!(context, "A::B::D", vec!["d_method()"]);
     }
 
+    #[test]
+    fn have_linearized_ancestors() {
+        // Todos are namespaces, so they must be the first entry of their own ancestor chain. Member lookups walk that
+        // chain, so an empty one makes every member of the Todo unreachable
+        let mut context = graph_test();
+        context.index_uri("file:///a.rb", {
+            r"
+            class A::B::C
+              def foo; end
+            end
+            "
+        });
+        context.index_uri("file:///d.rb", "class A::B::D < A::B::C; end");
+        context.resolve();
+
+        assert_declaration_kind_eq!(context, "A", "<TODO>");
+        assert_declaration_kind_eq!(context, "A::B", "<TODO>");
+        assert_ancestors_eq!(context, "A", ["A"]);
+        assert_ancestors_eq!(context, "A::B", ["A::B"]);
+
+        // Every member of a Todo is only reachable because the Todo lists itself in its own chain
+        assert_members_eq!(context, "A", ["B"]);
+        assert_members_eq!(context, "A::B", ["C", "D"]);
+
+        // Classes nested in a Todo still inherit from each other. Both the superclass path `A::B::C` and `D`'s own
+        // owner chain go through the Todos
+        assert_ancestors_eq!(
+            context,
+            "A::B::D",
+            ["A::B::D", "A::B::C", "Object", "Kernel", "BasicObject"]
+        );
+        assert_owner_eq!(context, "A::B::D", "A::B");
+        assert_descendants!(context, "A::B::C", ["A::B::D"]);
+    }
+
     #[test]
     fn promoted_incrementally() {
         // Index class A::B::C first (creates Todos), then provide real definitions.
@@ -4652,6 +4748,104 @@ mod promotability_tests {
         assert_eq!(*receiver.declaration_id(), DeclarationId::from("ENV::<ENV>"));
     }
 
+    #[test]
+    fn singleton_on_todo_is_preserved_and_relinearized_when_promoted_to_class() {
+        let mut context = graph_test();
+        context.index_uri("file:///placeholder.rb", "class Foo::Placeholder; end");
+        context.resolve();
+
+        assert_declaration_kind_eq!(context, "Foo", "<TODO>");
+
+        context.index_uri("file:///value.rb", "Foo.call");
+        context.resolve();
+
+        assert_singleton_class_eq!(context, "Foo", "Foo::<Foo>");
+
+        context.index_uri("file:///class.rb", "class Foo; end");
+        context.resolve();
+
+        assert_declaration_kind_eq!(context, "Foo", "Class");
+        assert_singleton_class_eq!(context, "Foo", "Foo::<Foo>");
+        assert_ancestors_eq!(
+            context,
+            "Foo::<Foo>",
+            [
+                "Foo::<Foo>",
+                "Object::<Object>",
+                "BasicObject::<BasicObject>",
+                "Class",
+                "Module",
+                "Object",
+                "Kernel",
+                "BasicObject"
+            ]
+        );
+    }
+
+    #[test]
+    fn singleton_on_todo_is_preserved_when_promoted_to_module() {
+        let mut context = graph_test();
+        context.index_uri("file:///placeholder.rb", "class Bar::Placeholder; end");
+        context.resolve();
+
+        assert_declaration_kind_eq!(context, "Bar", "<TODO>");
+
+        context.index_uri("file:///value.rb", "Bar.call");
+        context.resolve();
+
+        assert_singleton_class_eq!(context, "Bar", "Bar::<Bar>");
+
+        context.index_uri("file:///module.rb", "module Bar; end");
+        context.resolve();
+
+        assert_declaration_kind_eq!(context, "Bar", "Module");
+        assert_singleton_class_eq!(context, "Bar", "Bar::<Bar>");
+        assert_ancestors_eq!(
+            context,
+            "Bar::<Bar>",
+            ["Bar::<Bar>", "Module", "Object", "Kernel", "BasicObject"]
+        );
+    }
+
+    #[test]
+    fn higher_order_singleton_on_todo_is_relinearized_when_promoted_to_class() {
+        let mut context = graph_test();
+        context.index_uri("file:///placeholder.rb", "class Foo::Placeholder; end");
+        context.resolve();
+
+        context.index_uri("file:///value.rb", {
+            r"
+            class << Foo
+              class << self
+              end
+            end
+            "
+        });
+        context.resolve();
+
+        context.index_uri("file:///class.rb", "class Foo; end");
+        context.resolve();
+
+        assert_ancestors_eq!(
+            context,
+            "Foo::<Foo>::<<Foo>>",
+            [
+                "Foo::<Foo>::<<Foo>>",
+                "Object::<Object>::<<Object>>",
+                "BasicObject::<BasicObject>::<<BasicObject>>",
+                "Class::<Class>",
+                "Module::<Module>",
+                "Object::<Object>",
+                "BasicObject::<BasicObject>",
+                "Class",
+                "Module",
+                "Object",
+                "Kernel",
+                "BasicObject"
+            ]
+        );
+    }
+
     #[test]
     fn ivar_defined_inside_of_undefined_alias_namespace() {
         let mut context = graph_test();
@@ -5024,6 +5218,38 @@ mod rbs_tests {
         );
     }
 
+    #[test]
+    fn rbs_attributes_create_method_declarations_without_instance_variable_declarations() {
+        let mut context = graph_test();
+        context.index_rbs_uri("file:///attributes.rbs", {
+            r"
+            class Foo
+              attr_reader reader: String
+              attr_writer writer (@writer): Integer
+              attr_accessor accessor(): bool
+              private attr_accessor self.class_value (@class_value): Symbol
+            end
+            "
+        });
+        context.resolve();
+
+        assert_no_diagnostics!(&context);
+        for method in [
+            "Foo#reader()",
+            "Foo#writer=()",
+            "Foo#accessor()",
+            "Foo#accessor=()",
+            "Foo::<Foo>#class_value()",
+            "Foo::<Foo>#class_value=()",
+        ] {
+            assert_declaration_exists!(context, method);
+            assert_declaration_kind_eq!(context, method, "Method");
+        }
+        for instance_variable in ["Foo#@reader", "Foo#@writer", "Foo::<Foo>#@class_value"] {
+            assert_declaration_does_not_exist!(context, instance_variable);
+        }
+    }
+
     #[test]
     fn rbs_mixin_resolution() {
         let mut context = graph_test();
@@ -5263,8 +5489,9 @@ mod visibility_resolution_tests {
         assert_diagnostics_eq!(
             context,
             &[
-                "undefined-method-visibility-target: undefined method `Foo#nonexistent()` for visibility change (2:12-2:23)"
-            ]
+                "UndefinedMethodVisibilityTarget: undefined method `Foo#nonexistent()` for visibility change (2:12-2:23)"
+            ],
+            severity: Severity::Warning
         );
     }
 
@@ -5398,9 +5625,10 @@ mod visibility_resolution_tests {
         assert_diagnostics_eq!(
             context,
             &[
-                "undefined-constant-visibility-target: undefined constant `NOPE_ONE` for visibility change in `Foo` (2:21-2:29)",
-                "undefined-constant-visibility-target: undefined constant `NOPE_TWO` for visibility change in `Foo` (2:32-2:40)",
-            ]
+                "UndefinedConstantVisibilityTarget: undefined constant `NOPE_ONE` for visibility change in `Foo` (2:21-2:29)",
+                "UndefinedConstantVisibilityTarget: undefined constant `NOPE_TWO` for visibility change in `Foo` (2:32-2:40)",
+            ],
+            severity: Severity::Warning
         );
     }
 
@@ -5424,7 +5652,7 @@ mod visibility_resolution_tests {
         assert_diagnostics_eq!(
             context,
             &[
-                "undefined-constant-visibility-target: undefined constant `CONST` for visibility change in `Child` (6:21-6:26)"
+                "UndefinedConstantVisibilityTarget: undefined constant `CONST` for visibility change in `Child` (6:21-6:26)"
             ]
         );
         assert_visibility_eq!(context, "Parent::CONST", Visibility::Public);
@@ -5566,7 +5794,7 @@ mod visibility_resolution_tests {
         assert_diagnostics_eq!(
             context,
             &[
-                "undefined-method-visibility-target: undefined method `Foo::<Foo>#nonexistent()` for visibility change (2:25-2:36)"
+                "UndefinedMethodVisibilityTarget: undefined method `Foo::<Foo>#nonexistent()` for visibility change (2:25-2:36)"
             ]
         );
     }
@@ -5594,7 +5822,7 @@ mod visibility_resolution_tests {
         assert_diagnostics_eq!(
             context,
             &[
-                "undefined-method-visibility-target: undefined method `Foo::<Foo>#missing()` for visibility change (2:25-2:32)"
+                "UndefinedMethodVisibilityTarget: undefined method `Foo::<Foo>#missing()` for visibility change (2:25-2:32)"
             ]
         );
 
@@ -5620,7 +5848,7 @@ mod visibility_resolution_tests {
         assert_diagnostics_eq!(
             context,
             &[
-                "undefined-method-visibility-target: undefined method `Foo::<Foo>#missing()` for visibility change (2:25-2:32)"
+                "UndefinedMethodVisibilityTarget: undefined method `Foo::<Foo>#missing()` for visibility change (2:25-2:32)"
             ]
         );
 
@@ -5641,7 +5869,7 @@ mod visibility_resolution_tests {
 
     #[test]
     fn retroactive_singleton_method_visibility_inline_def() {
-        let mut context = GraphTest::new();
+        let mut context = graph_test();
         context.index_uri(
             "file:///foo.rb",
             r"
@@ -5658,7 +5886,7 @@ mod visibility_resolution_tests {
 
     #[test]
     fn retroactive_singleton_method_visibility_array_form() {
-        let mut context = GraphTest::new();
+        let mut context = graph_test();
         context.index_uri(
             "file:///foo.rb",
             r#"
@@ -5682,7 +5910,7 @@ mod visibility_resolution_tests {
 
     #[test]
     fn inline_module_function() {
-        let mut context = GraphTest::new();
+        let mut context = graph_test();
         context.index_uri(
             "file:///foo.rb",
             r"
@@ -5722,7 +5950,7 @@ mod visibility_resolution_tests {
 
     #[test]
     fn retroactive_module_function() {
-        let mut context = GraphTest::new();
+        let mut context = graph_test();
         context.index_uri(
             "file:///foo.rb",
             r"
@@ -5746,7 +5974,7 @@ mod visibility_resolution_tests {
 
     #[test]
     fn retroactive_module_function_undefined_target_emits_single_diagnostic() {
-        let mut context = GraphTest::new();
+        let mut context = graph_test();
         context.index_uri(
             "file:///foo.rb",
             r"
@@ -5760,7 +5988,7 @@ mod visibility_resolution_tests {
         // The singleton-side def stays silent; only the instance-side def emits.
         assert_diagnostics_eq!(
             context,
-            &["undefined-method-visibility-target: undefined method `Foo#missing()` for visibility change (2:20-2:27)"]
+            &["UndefinedMethodVisibilityTarget: undefined method `Foo#missing()` for visibility change (2:20-2:27)"]
         );
         assert_declaration_does_not_exist!(context, "Foo::<Foo>#missing()");
         assert_declaration_does_not_exist!(context, "Foo::<Foo>");
@@ -5768,7 +5996,7 @@ mod visibility_resolution_tests {
 
     #[test]
     fn retroactive_module_function_singleton_companion_cleared_when_removed_multi_file() {
-        let mut context = GraphTest::new();
+        let mut context = graph_test();
         context.index_uri(
             "file:///a.rb",
             r"
@@ -5810,7 +6038,7 @@ mod visibility_resolution_tests {
 
     #[test]
     fn retroactive_module_function_singleton_companion_cleared_when_removed() {
-        let mut context = GraphTest::new();
+        let mut context = graph_test();
         context.index_uri(
             "file:///foo.rb",
             r"

data/rust/rubydex/src/test_utils/context.rs

@@ -1,4 +1,5 @@
 use super::normalize_indentation;
+use crate::path_helpers;
 use std::fs;
 use std::path::{Path, PathBuf};
 use tempfile::TempDir;
@@ -37,7 +38,7 @@ impl Context {
     #[must_use]
     pub fn new() -> Self {
         let root = tempfile::tempdir().expect("failed to create temp dir");
-        let absolute_path = fs::canonicalize(root.path()).unwrap();
+        let absolute_path = path_helpers::resolved(root.path()).unwrap();
         Self {
             _root: root,
             absolute_path,

data/rust/rubydex/src/test_utils/graph_test.rs

@@ -540,18 +540,13 @@ macro_rules! assert_descendants {
             .declarations()
             .get(&$crate::model::ids::DeclarationId::from($parent))
             .unwrap();
-        let actual = match parent {
-            $crate::model::declaration::Declaration::Namespace($crate::model::declaration::Namespace::Class(class)) => {
-                class.descendants().iter().cloned().collect::<Vec<_>>()
-            }
-            $crate::model::declaration::Declaration::Namespace($crate::model::declaration::Namespace::Module(
-                module,
-            )) => module.descendants().iter().cloned().collect::<Vec<_>>(),
-            $crate::model::declaration::Declaration::Namespace(
-                $crate::model::declaration::Namespace::SingletonClass(singleton),
-            ) => singleton.descendants().iter().cloned().collect::<Vec<_>>(),
-            _ => panic!("Tried to get descendants for a declaration that isn't a namespace"),
-        };
+        let actual = parent
+            .as_namespace()
+            .expect("Tried to get descendants for a declaration that isn't a namespace")
+            .descendants()
+            .iter()
+            .cloned()
+            .collect::<Vec<_>>();
 
         for descendant in &$descendants {
             let descendant_id = $crate::model::ids::DeclarationId::from(*descendant);
@@ -667,6 +662,25 @@ macro_rules! assert_instance_variables_eq {
 #[cfg(test)]
 #[macro_export]
 macro_rules! assert_diagnostics_eq {
+    ($context:expr, $expected_diagnostics:expr, severity: $expected_severity:expr) => {{
+        let context = &$context;
+        $crate::assert_diagnostics_eq!(context, $expected_diagnostics);
+
+        let expected_severity = $expected_severity;
+        let actual_severities = context
+            .graph()
+            .all_diagnostics()
+            .iter()
+            .map(|diagnostic| diagnostic.rule().default_severity())
+            .collect::<Vec<_>>();
+        assert_eq!(
+            vec![expected_severity; actual_severities.len()],
+            actual_severities,
+            "diagnostic severities mismatch: expected all `{:?}`, got `{:?}`",
+            expected_severity,
+            actual_severities
+        );
+    }};
     ($context:expr, $expected_diagnostics:expr) => {{
         assert_eq!($expected_diagnostics, $context.format_diagnostics(&[]).as_slice());
     }};

data/rust/rubydex/src/test_utils/local_graph_test.rs

@@ -557,6 +557,25 @@ macro_rules! assert_method_has_receiver {
 #[cfg(test)]
 #[macro_export]
 macro_rules! assert_local_diagnostics_eq {
+    ($context:expr, $expected_diagnostics:expr, severity: $expected_severity:expr) => {{
+        let context = &$context;
+        $crate::assert_local_diagnostics_eq!(context, $expected_diagnostics);
+
+        let expected_severity = $expected_severity;
+        let actual_severities = context
+            .graph()
+            .diagnostics()
+            .iter()
+            .map(|diagnostic| diagnostic.rule().default_severity())
+            .collect::<Vec<_>>();
+        assert_eq!(
+            vec![expected_severity; actual_severities.len()],
+            actual_severities,
+            "diagnostic severities mismatch: expected all `{:?}`, got `{:?}`",
+            expected_severity,
+            actual_severities
+        );
+    }};
     ($context:expr, $expected_diagnostics:expr) => {{
         let mut diagnostics = $context.graph().diagnostics().iter().collect::<Vec<_>>();
         diagnostics.sort_by_key(|d| d.offset());

data/rust/rubydex/tests/cli.rs

@@ -60,7 +60,7 @@ fn single_directory_argument_is_workspace_root_for_config() {
     with_context(|context| {
         context.write("included.rb", "class Included\nend\n");
         context.write("excluded/skipped.rb", "class Skipped\nend\n");
-        context.write("rubydex.toml", "exclude = [\"excluded\"]\n");
+        context.write("rubydex.toml", "[graph]\nexclude = [\"excluded\"]\n");
 
         rdx(&[context.absolute_path().to_str().unwrap()])
             .success()
@@ -74,7 +74,7 @@ fn first_directory_argument_is_workspace_root_for_config() {
     with_context(|context| {
         context.write("included/kept.rb", "class Included\nend\n");
         context.write("excluded/skipped.rb", "class Skipped\nend\n");
-        context.write("rubydex.toml", "exclude = [\"excluded\"]\n");
+        context.write("rubydex.toml", "[graph]\nexclude = [\"excluded\"]\n");
 
         rdx(&[
             context.absolute_path().to_str().unwrap(),
@@ -92,7 +92,7 @@ fn single_file_argument_is_not_used_as_workspace_root() {
     with_context(|context| {
         context.write("included.rb", "class Included\nend\n");
         context.write("excluded/skipped.rb", "class Skipped\nend\n");
-        context.write("rubydex.toml", "exclude = [\"excluded\"]\n");
+        context.write("rubydex.toml", "[graph]\nexclude = [\"excluded\"]\n");
 
         rdx(&[context.absolute_path_to("excluded/skipped.rb").to_str().unwrap()])
             .success()
@@ -106,7 +106,7 @@ fn first_file_argument_is_not_used_as_workspace_root() {
     with_context(|context| {
         context.write("included.rb", "class Included\nend\n");
         context.write("excluded/skipped.rb", "class Skipped\nend\n");
-        context.write("rubydex.toml", "exclude = [\"excluded\"]\n");
+        context.write("rubydex.toml", "[graph]\nexclude = [\"excluded\"]\n");
 
         rdx(&[
             context.absolute_path_to("included.rb").to_str().unwrap(),