Resolve singleton method visibility

Author: alexcrocha

rust/rubydex/src/diagnostic.rs

@@ -110,4 +110,5 @@ rules! {
     // Resolution
     UndefinedMethodVisibilityTarget;
     UndefinedConstantVisibilityTarget;
+    UndefinedSingletonMethodVisibilityTarget;
 }

rust/rubydex/src/model/graph.rs

@@ -656,6 +656,7 @@ impl Graph {
                     };
                     let visibility = match definition {
                         Definition::MethodVisibility(vis) => Some(*vis.visibility()),
+                        Definition::SingletonMethodVisibility(vis) => Some(*vis.visibility()),
                         Definition::Method(method) => Some(*method.visibility()),
                         Definition::AttrAccessor(attr) => Some(*attr.visibility()),
                         Definition::AttrReader(attr) => Some(*attr.visibility()),

rust/rubydex/src/resolution.rs

@@ -274,6 +274,7 @@ impl<'a> Resolver<'a> {
     #[allow(clippy::too_many_lines)]
     fn handle_remaining_definitions(&mut self, other_ids: Vec<DefinitionId>) {
         let mut method_visibility_ids = Vec::new();
+        let mut singleton_method_visibility_ids = Vec::new();
 
         for id in other_ids {
             match self.graph.definitions().get(&id).unwrap() {
@@ -607,7 +608,9 @@ impl<'a> Resolver<'a> {
                 Definition::MethodVisibility(_) => {
                     method_visibility_ids.push(id);
                 }
-                Definition::SingletonMethodVisibility(_) => {}
+                Definition::SingletonMethodVisibility(_) => {
+                    singleton_method_visibility_ids.push(id);
+                }
                 Definition::Class(_)
                 | Definition::SingletonClass(_)
                 | Definition::Module(_)
@@ -619,6 +622,98 @@ impl<'a> Resolver<'a> {
         }
 
         self.resolve_method_visibilities(method_visibility_ids);
+        self.resolve_singleton_method_visibilities(singleton_method_visibility_ids);
+    }
+
+    /// Resolves `private_class_method` / `public_class_method` calls
+    fn resolve_singleton_method_visibilities(&mut self, visibility_ids: Vec<DefinitionId>) {
+        let mut pending_work = Vec::new();
+
+        for id in visibility_ids {
+            let Definition::SingletonMethodVisibility(singleton_visibility) =
+                self.graph.definitions().get(&id).unwrap()
+            else {
+                unreachable!()
+            };
+
+            let str_id = *singleton_visibility.target();
+            let uri_id = *singleton_visibility.uri_id();
+            let offset = singleton_visibility.offset().clone();
+            let lexical_nesting_id = *singleton_visibility.lexical_nesting_id();
+            let receiver = *singleton_visibility.receiver();
+
+            let attached_namespace_id = if let Some(receiver_name_id) = receiver {
+                let NameRef::Resolved(resolved) = self.graph.names().get(&receiver_name_id).unwrap() else {
+                    pending_work.push(Unit::Definition(id));
+                    continue;
+                };
+                let Some(namespace_id) = self.resolve_to_namespace(*resolved.declaration_id()) else {
+                    continue;
+                };
+                namespace_id
+            } else {
+                let Some(decl_id) = self.resolve_lexical_owner(lexical_nesting_id, id) else {
+                    continue;
+                };
+                decl_id
+            };
+
+            let Some(singleton_id) = self.get_or_create_singleton_class(attached_namespace_id, true) else {
+                continue;
+            };
+
+            let Some(Declaration::Namespace(namespace)) = self.graph.declarations().get(&singleton_id) else {
+                continue;
+            };
+
+            let mut visibility_applied = false;
+            let mut has_partial = false;
+
+            let ancestor_ids: Vec<Ancestor> = namespace.ancestors().iter().copied().collect();
+
+            for ancestor in ancestor_ids {
+                match ancestor {
+                    Ancestor::Complete(ancestor_id) => {
+                        let has_member = self
+                            .graph
+                            .declarations()
+                            .get(&ancestor_id)
+                            .and_then(|decl| decl.as_namespace())
+                            .and_then(|ns| ns.member(&str_id))
+                            .is_some();
+
+                        if has_member {
+                            self.create_declaration(str_id, id, singleton_id, |name| {
+                                Declaration::Method(Box::new(MethodDeclaration::new(name, singleton_id)))
+                            });
+                            visibility_applied = true;
+                            break;
+                        }
+                    }
+                    Ancestor::Partial(_) => has_partial = true,
+                }
+            }
+
+            if visibility_applied {
+                continue;
+            }
+
+            if has_partial {
+                pending_work.push(Unit::Definition(id));
+            } else {
+                let method_name = self.graph.strings().get(&str_id).unwrap().as_str().to_string();
+                let owner_name = self.graph.declarations().get(&singleton_id).unwrap().name().to_string();
+                let diagnostic = Diagnostic::new(
+                    Rule::UndefinedSingletonMethodVisibilityTarget,
+                    uri_id,
+                    offset,
+                    format!("undefined singleton method `{method_name}` for visibility change in `{owner_name}`"),
+                );
+                self.graph.add_document_diagnostic(uri_id, diagnostic);
+            }
+        }
+
+        self.graph.extend_work(pending_work);
     }
 
     /// Resolves retroactive method visibility changes (`private :foo`, `protected :foo`, `public :foo`).

rust/rubydex/src/resolution_tests.rs

@@ -5306,4 +5306,155 @@ mod visibility_resolution_tests {
 
         assert_visibility_eq!(context, "Foo::BAR", Visibility::Private);
     }
+
+    #[test]
+    fn retroactive_singleton_method_visibility_on_direct_member() {
+        let mut context = GraphTest::new();
+        context.index_uri(
+            "file:///foo.rb",
+            r"
+            class Foo
+              def self.bar; end
+              def self.baz; end
+
+              private_class_method :bar
+              public_class_method :baz
+            end
+            ",
+        );
+        context.resolve();
+
+        assert_no_diagnostics!(&context);
+        assert_visibility_eq!(context, "Foo::<Foo>#bar()", Visibility::Private);
+        assert_visibility_eq!(context, "Foo::<Foo>#baz()", Visibility::Public);
+    }
+
+    #[test]
+    fn retroactive_singleton_method_visibility_via_qualified_receiver() {
+        let mut context = GraphTest::new();
+        context.index_uri(
+            "file:///foo.rb",
+            r"
+            class Foo
+              def self.bar; end
+            end
+
+            Foo.private_class_method :bar
+            ",
+        );
+        context.resolve();
+
+        assert_no_diagnostics!(&context);
+        assert_visibility_eq!(context, "Foo::<Foo>#bar()", Visibility::Private);
+    }
+
+    #[test]
+    fn retroactive_singleton_method_visibility_on_inherited_method() {
+        let mut context = GraphTest::new();
+        context.index_uri(
+            "file:///foo.rb",
+            r"
+            class Parent
+              def self.foo; end
+            end
+
+            class Child < Parent
+              private_class_method :foo
+            end
+            ",
+        );
+        context.resolve();
+
+        assert_no_diagnostics!(&context);
+        assert_declaration_exists!(context, "Child::<Child>#foo()");
+        assert_visibility_eq!(context, "Child::<Child>#foo()", Visibility::Private);
+        assert_visibility_eq!(context, "Parent::<Parent>#foo()", Visibility::Public);
+    }
+
+    #[test]
+    fn retroactive_singleton_method_visibility_on_undefined_method_emits_diagnostic() {
+        let mut context = GraphTest::new();
+        context.index_uri(
+            "file:///foo.rb",
+            r"
+            class Foo
+              private_class_method :nonexistent
+            end
+            ",
+        );
+        context.resolve();
+
+        assert_diagnostics_eq!(
+            context,
+            &[
+                "undefined-singleton-method-visibility-target: undefined singleton method `nonexistent()` for visibility change in `Foo::<Foo>` (2:25-2:36)"
+            ]
+        );
+    }
+
+    #[test]
+    fn retroactive_singleton_method_visibility_clears_when_call_removed() {
+        let mut context = GraphTest::new();
+        context.index_uri(
+            "file:///foo.rb",
+            r"
+            class Parent
+              def self.foo; end
+            end
+
+            class Child < Parent; end
+            ",
+        );
+        context.index_uri(
+            "file:///vis.rb",
+            r"
+            Child.private_class_method :foo
+            ",
+        );
+        context.resolve();
+
+        assert_no_diagnostics!(&context);
+        assert_declaration_exists!(context, "Child::<Child>#foo()");
+        assert_visibility_eq!(context, "Child::<Child>#foo()", Visibility::Private);
+
+        context.delete_uri("file:///vis.rb");
+        context.resolve();
+
+        assert_no_diagnostics!(&context);
+        assert_declaration_does_not_exist!(context, "Child::<Child>#foo()");
+        assert_visibility_eq!(context, "Parent::<Parent>#foo()", Visibility::Public);
+    }
+
+    #[test]
+    fn retroactive_singleton_method_visibility_undefined_target_diagnostic_clears_when_file_deleted() {
+        let mut context = GraphTest::new();
+        context.index_uri(
+            "file:///foo.rb",
+            r"
+            class Foo
+            end
+            ",
+        );
+        context.index_uri(
+            "file:///bad.rb",
+            r"
+            class Foo
+              private_class_method :missing
+            end
+            ",
+        );
+        context.resolve();
+
+        assert_diagnostics_eq!(
+            context,
+            &[
+                "undefined-singleton-method-visibility-target: undefined singleton method `missing()` for visibility change in `Foo::<Foo>` (2:25-2:32)"
+            ]
+        );
+
+        context.delete_uri("file:///bad.rb");
+        context.resolve();
+
+        assert_no_diagnostics!(&context);
+    }
 }

test/declaration_test.rb

@@ -789,6 +789,58 @@ class Foo
     end
   end
 
+  def test_class_method_visibility_via_private_class_method
+    with_context do |context|
+      context.write!("file1.rb", <<~RUBY)
+        class Foo
+          def self.bar; end
+          private_class_method :bar
+        end
+      RUBY
+
+      graph = Rubydex::Graph.new
+      graph.index_all(context.glob("**/*.rb"))
+      graph.resolve
+
+      assert_equal(:private, graph["Foo::<Foo>#bar()"].visibility)
+    end
+  end
+
+  def test_class_method_visibility_via_public_class_method
+    with_context do |context|
+      context.write!("file1.rb", <<~RUBY)
+        class Foo
+          def self.bar; end
+          public_class_method :bar
+        end
+      RUBY
+
+      graph = Rubydex::Graph.new
+      graph.index_all(context.glob("**/*.rb"))
+      graph.resolve
+
+      assert_equal(:public, graph["Foo::<Foo>#bar()"].visibility)
+    end
+  end
+
+  def test_class_method_visibility_via_qualified_receiver
+    with_context do |context|
+      context.write!("file1.rb", <<~RUBY)
+        class Foo
+          def self.bar; end
+        end
+
+        Foo.private_class_method :bar
+      RUBY
+
+      graph = Rubydex::Graph.new
+      graph.index_all(context.glob("**/*.rb"))
+      graph.resolve
+
+      assert_equal(:private, graph["Foo::<Foo>#bar()"].visibility)
+    end
+  end
+
   def test_constant_alias_visibility
     with_context do |context|
       context.write!("file1.rb", <<~RUBY)