rubydex 0.2.9 → 0.4.0

data/rust/rubydex/src/resolution_tests.rs

@@ -8,9 +8,8 @@ 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},
-    resolution::Resolver,
     test_utils::GraphTest,
 };
 
@@ -1495,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 {
@@ -2133,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 {
@@ -3034,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
@@ -3097,13 +3157,14 @@ mod declaration_creation_tests {
     #[test]
     fn resolution_for_ambiguous_namespace_definitions() {
         // Like many examples of Ruby code that is ambiguous to static analysis, this example is ambiguous due to
-        // require order. If `foo.rb` is loaded first, then `Bar` doesn't exist, Ruby crashes and we should emit an
-        // error or warning for a non existing constant.
+        // require order. If `a_qualified.rb` is loaded first, then `Bar` doesn't exist, Ruby crashes and we should
+        // emit an error or warning for a non existing constant.
         //
-        // If `bar.rb` is loaded first, then `Bar` resolves to top level `Bar` and `Bar::Baz` is defined, completely
-        // escaping the `Foo` nesting.
+        // If `z_parent.rb` is loaded first, then `Bar` resolves to top level `Bar` and `Bar::Baz` is defined,
+        // completely escaping the `Foo` nesting. The URIs intentionally sort in the opposite order: name complexity
+        // must take precedence over URI so the top level `Bar` is resolved before the qualified `Bar::Baz` definition.
         let mut context = graph_test();
-        context.index_uri("file:///foo.rb", {
+        context.index_uri("file:///a_qualified.rb", {
             r"
             module Foo
               class Bar::Baz
@@ -3111,7 +3172,7 @@ mod declaration_creation_tests {
             end
             "
         });
-        context.index_uri("file:///bar.rb", {
+        context.index_uri("file:///z_parent.rb", {
             r"
             module Bar
             end
@@ -3123,62 +3184,11 @@ mod declaration_creation_tests {
 
         assert_no_members!(context, "Foo");
         assert_owner_eq!(context, "Foo", "Object");
+        assert_declaration_does_not_exist!(context, "Foo::Bar");
 
         assert_members_eq!(context, "Bar", ["Baz"]);
         assert_owner_eq!(context, "Bar", "Object");
     }
-
-    #[test]
-    fn expected_name_depth_order() {
-        let mut context = graph_test();
-        context.index_uri("file:///foo.rb", {
-            r"
-            module Foo
-              module Bar
-                module Baz
-                end
-
-                module ::Top
-                  class AfterTop
-                  end
-                end
-              end
-
-              module Qux::Zip
-                module Zap
-                  class Zop::Boop
-                  end
-                end
-              end
-            end
-            "
-        });
-
-        let depths = Resolver::compute_name_depths(context.graph().names());
-        let mut names = context
-            .graph()
-            .names()
-            .iter()
-            .filter(|(_, n)| {
-                !["Kernel", "BasicObject", "Object", "Module", "Class"]
-                    .contains(&context.graph().strings().get(n.str()).unwrap().as_str())
-            })
-            .collect::<Vec<_>>();
-        assert_eq!(10, names.len());
-
-        names.sort_by_key(|(id, _)| depths.get(id).unwrap());
-
-        assert_eq!(
-            [
-                "Top", "Foo", "Bar", "Qux", "AfterTop", "Baz", "Zip", "Zap", "Zop", "Boop"
-            ],
-            names
-                .iter()
-                .map(|(_, n)| context.graph().strings().get(n.str()).unwrap().as_str())
-                .collect::<Vec<_>>()
-                .as_slice()
-        );
-    }
 }
 
 mod singleton_class_tests {
@@ -3973,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.
@@ -4535,6 +4580,7 @@ mod promotability_tests {
 
         context.resolve();
         assert_no_diagnostics!(&context);
+        assert_declaration_kind_eq!(context, "Qux", "<TODO>");
         assert_declaration_exists!(context, "Qux::<Qux>");
     }
 
@@ -4570,9 +4616,8 @@ mod promotability_tests {
 
     #[test]
     fn promoted_constant_has_correct_ancestors() {
-        // When a promotable constant is auto-promoted via singleton class access, we conservatively
-        // promote to a module (not a class) since we don't know what the call returns.
-        // Modules don't inherit from Object.
+        // When a promotable constant is auto-promoted via singleton class access, its kind remains unknown.
+        // Todos do not inherit from Object.
         let mut context = graph_test();
         context.index_uri("file:///foo.rb", {
             r"
@@ -4583,6 +4628,7 @@ mod promotability_tests {
 
         context.resolve();
         assert_no_diagnostics!(&context);
+        assert_declaration_kind_eq!(context, "Foo", "<TODO>");
         assert_ancestors_eq!(context, "Foo", ["Foo"]);
     }
 
@@ -4633,8 +4679,8 @@ mod promotability_tests {
         });
 
         context.resolve();
-        assert_declaration_kind_eq!(context, "Foo", "Module");
-        assert_declaration_kind_eq!(context, "Foo::Bar", "Module");
+        assert_declaration_kind_eq!(context, "Foo", "<TODO>");
+        assert_declaration_kind_eq!(context, "Foo::Bar", "<TODO>");
         assert_declaration_kind_eq!(context, "Foo::Bar::Baz", "Constant");
     }
 
@@ -4652,7 +4698,7 @@ mod promotability_tests {
         });
 
         context.resolve();
-        assert_declaration_kind_eq!(context, "Foo", "Module");
+        assert_declaration_kind_eq!(context, "Foo", "<TODO>");
         assert_declaration_exists!(context, "Foo::<Foo>#bar()");
     }
 
@@ -4675,6 +4721,131 @@ mod promotability_tests {
         assert_declaration_does_not_exist!(context, "Foo::<Foo>#bar()");
     }
 
+    #[test]
+    fn rbs_constant_is_promotable_for_singleton_call() {
+        let mut context = graph_test();
+        context.index_rbs_uri("file:///env.rbs", "ENV: untyped");
+        context.index_uri("file:///env.rb", {
+            r#"
+            ENV.fetch("FEATURE")
+            "#
+        });
+        context.resolve();
+
+        assert_no_diagnostics!(&context);
+        assert_declaration_exists!(context, "ENV::<ENV>");
+
+        let fetch = context
+            .graph()
+            .method_references()
+            .values()
+            .find(|method| *method.str() == "fetch".into())
+            .expect("ENV.fetch should be indexed");
+        let receiver_name_id = fetch.receiver().expect("ENV.fetch should have a receiver");
+        let NameRef::Resolved(receiver) = context.graph().names().get(&receiver_name_id).unwrap() else {
+            panic!("ENV.fetch receiver should resolve");
+        };
+        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();
@@ -4882,6 +5053,67 @@ mod rbs_tests {
         assert_declaration_exists!(context, "Foo::Bar::Baz");
     }
 
+    #[test]
+    fn rbs_qualified_mixin_resolves_through_parent_scope() {
+        let mut context = graph_test();
+        context.index_rbs_uri("file:///minitest.rbs", {
+            r"
+            module Minitest
+              module Guard
+              end
+
+              module Assertions
+              end
+
+              class Runnable
+              end
+            end
+            "
+        });
+        context.index_rbs_uri("file:///minitest/test.rbs", {
+            r"
+            class Minitest::Test < ::Minitest::Runnable
+              include Minitest::Assertions
+              include Minitest::Guard
+              extend Minitest::Guard
+            end
+            "
+        });
+        context.resolve();
+
+        assert_no_diagnostics!(&context);
+
+        assert_ancestors_eq!(
+            context,
+            "Minitest::Test",
+            [
+                "Minitest::Test",
+                "Minitest::Guard",
+                "Minitest::Assertions",
+                "Minitest::Runnable",
+                "Object",
+                "Kernel",
+                "BasicObject"
+            ]
+        );
+        assert_ancestors_eq!(
+            context,
+            "Minitest::Test::<Test>",
+            [
+                "Minitest::Test::<Test>",
+                "Minitest::Guard",
+                "Minitest::Runnable::<Runnable>",
+                "Object::<Object>",
+                "BasicObject::<BasicObject>",
+                "Class",
+                "Module",
+                "Object",
+                "Kernel",
+                "BasicObject"
+            ]
+        );
+    }
+
     #[test]
     fn rbs_qualified_name_inside_nested_module() {
         let mut context = graph_test();
@@ -4986,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();
@@ -5225,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
         );
     }
 
@@ -5360,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
         );
     }
 
@@ -5386,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);
@@ -5528,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)"
             ]
         );
     }
@@ -5556,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)"
             ]
         );
 
@@ -5582,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)"
             ]
         );
 
@@ -5603,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"
@@ -5620,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#"
@@ -5641,4 +5907,164 @@ mod visibility_resolution_tests {
         assert_visibility_eq!(context, "Foo::<Foo>#b()", Visibility::Private);
         assert_visibility_eq!(context, "Foo::<Foo>#c()", Visibility::Public);
     }
+
+    #[test]
+    fn inline_module_function() {
+        let mut context = graph_test();
+        context.index_uri(
+            "file:///foo.rb",
+            r"
+            module Foo
+              module_function def bar; end
+            end
+            ",
+        );
+        context.resolve();
+
+        assert_no_diagnostics!(&context);
+        assert_visibility_eq!(context, "Foo#bar()", Visibility::Private);
+        assert_visibility_eq!(context, "Foo::<Foo>#bar()", Visibility::Public);
+    }
+
+    #[test]
+    fn inline_module_function_singleton_companion_visibility_can_be_changed() {
+        let mut context = graph_test();
+        context.index_uri(
+            "file:///foo.rb",
+            r"
+            module Foo
+              module_function def bar; end
+
+              class << self
+                private :bar
+              end
+            end
+            ",
+        );
+        context.resolve();
+
+        assert_no_diagnostics!(&context);
+        assert_visibility_eq!(context, "Foo#bar()", Visibility::Private);
+        assert_visibility_eq!(context, "Foo::<Foo>#bar()", Visibility::Private);
+    }
+
+    #[test]
+    fn retroactive_module_function() {
+        let mut context = graph_test();
+        context.index_uri(
+            "file:///foo.rb",
+            r"
+            module Foo
+              def bar; end
+              module_function :bar
+            end
+            ",
+        );
+        context.resolve();
+
+        assert_no_diagnostics!(&context);
+        assert_visibility_eq!(context, "Foo#bar()", Visibility::Private);
+        assert_visibility_eq!(context, "Foo::<Foo>#bar()", Visibility::Public);
+
+        // Instance: Method def + MethodVisibility def
+        assert_declaration_definitions_count_eq!(context, "Foo#bar()", 2);
+        // Singleton companion: only the MethodVisibility def is attached
+        assert_declaration_definitions_count_eq!(context, "Foo::<Foo>#bar()", 1);
+    }
+
+    #[test]
+    fn retroactive_module_function_undefined_target_emits_single_diagnostic() {
+        let mut context = graph_test();
+        context.index_uri(
+            "file:///foo.rb",
+            r"
+            module Foo
+              module_function :missing
+            end
+            ",
+        );
+        context.resolve();
+
+        // The singleton-side def stays silent; only the instance-side def emits.
+        assert_diagnostics_eq!(
+            context,
+            &["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>");
+    }
+
+    #[test]
+    fn retroactive_module_function_singleton_companion_cleared_when_removed_multi_file() {
+        let mut context = graph_test();
+        context.index_uri(
+            "file:///a.rb",
+            r"
+            module Foo
+              def bar; end
+              module_function :bar
+            end
+            ",
+        );
+        context.index_uri(
+            "file:///b.rb",
+            r"
+            module Foo
+              def baz; end
+            end
+            ",
+        );
+        context.resolve();
+
+        assert_visibility_eq!(context, "Foo::<Foo>#bar()", Visibility::Public);
+
+        // Re-index a.rb without `module_function :bar`. Foo still has b.rb's Module def, so the
+        // namespace stays alive and no cascade through Foo's singleton class runs. The singleton
+        // companion must still be cleaned up via reverse-lookup invalidation of its own def.
+        context.index_uri(
+            "file:///a.rb",
+            r"
+            module Foo
+              def bar; end
+            end
+            ",
+        );
+        context.resolve();
+
+        assert_no_diagnostics!(&context);
+        assert_visibility_eq!(context, "Foo#bar()", Visibility::Public);
+        assert_declaration_does_not_exist!(context, "Foo::<Foo>#bar()");
+    }
+
+    #[test]
+    fn retroactive_module_function_singleton_companion_cleared_when_removed() {
+        let mut context = graph_test();
+        context.index_uri(
+            "file:///foo.rb",
+            r"
+            module Foo
+              def bar; end
+              module_function :bar
+            end
+            ",
+        );
+        context.resolve();
+
+        assert_visibility_eq!(context, "Foo::<Foo>#bar()", Visibility::Public);
+
+        context.index_uri(
+            "file:///foo.rb",
+            r"
+            module Foo
+              def bar; end
+            end
+            ",
+        );
+        context.resolve();
+
+        assert_no_diagnostics!(&context);
+        assert_visibility_eq!(context, "Foo#bar()", Visibility::Public);
+        assert_declaration_does_not_exist!(context, "Foo::<Foo>#bar()");
+        assert_declaration_does_not_exist!(context, "Foo::<Foo>");
+    }
 }