Remove T::Enum for entry visibility (#3442)

Author: vinistock

lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb

@@ -265,11 +265,11 @@ def on_call_node_enter(node)
       when :include, :prepend, :extend
         handle_module_operation(node, message)
       when :public
-        handle_visibility_change(node, Entry::Visibility::PUBLIC)
+        handle_visibility_change(node, :public)
       when :protected
-        handle_visibility_change(node, Entry::Visibility::PROTECTED)
+        handle_visibility_change(node, :protected)
       when :private
-        handle_visibility_change(node, Entry::Visibility::PRIVATE)
+        handle_visibility_change(node, :private)
       when :module_function
         handle_module_function(node)
       when :private_class_method
@@ -343,7 +343,7 @@ def on_def_node_enter(node)
             name_location,
             comments,
             signatures,
-            Entry::Visibility::PUBLIC,
+            :public,
             singleton,
           ))
         end
@@ -465,8 +465,8 @@ def on_class_variable_write_node_enter(node)
       handle_class_variable(node, node.name_loc)
     end
 
-    #: (String name, Prism::Location node_location, Array[Entry::Signature] signatures, ?visibility: Entry::Visibility, ?comments: String?) -> void
-    def add_method(name, node_location, signatures, visibility: Entry::Visibility::PUBLIC, comments: nil)
+    #: (String name, Prism::Location node_location, Array[Entry::Signature] signatures, ?visibility: Symbol, ?comments: String?) -> void
+    def add_method(name, node_location, signatures, visibility: :public, comments: nil)
       location = Location.from_prism_location(node_location, @code_units_cache)
 
       @index.add(Entry::Method.new(
@@ -621,7 +621,7 @@ def handle_private_constant(node)
       # The private_constant method does not resolve the constant name. It always points to a constant that needs to
       # exist in the current namespace
       entries = @index[fully_qualify_name(name)]
-      entries&.each { |entry| entry.visibility = Entry::Visibility::PRIVATE }
+      entries&.each { |entry| entry.visibility = :private }
     end
 
     #: (Prism::CallNode node) -> void
@@ -868,7 +868,7 @@ def handle_module_function(node)
           entry_owner_name = entry.owner&.name
           next unless entry_owner_name
 
-          entry.visibility = Entry::Visibility::PRIVATE
+          entry.visibility = :private
 
           singleton = @index.existing_or_new_singleton_class(entry_owner_name)
           location = Location.from_prism_location(argument.location, @code_units_cache)
@@ -879,7 +879,7 @@ def handle_module_function(node)
             location,
             collect_comments(node)&.concat(entry.comments),
             entry.signatures,
-            Entry::Visibility::PUBLIC,
+            :public,
             singleton,
           ))
         end
@@ -894,7 +894,7 @@ def handle_private_class_method(node)
       # If we're passing a method definition directly to `private_class_method`, push a new private scope. That will be
       # applied when the indexer finds the method definition and then popped on `call_node_leave`
       if arguments.first.is_a?(Prism::DefNode)
-        @visibility_stack.push(VisibilityScope.new(visibility: Entry::Visibility::PRIVATE))
+        @visibility_stack.push(VisibilityScope.new(visibility: :private))
         return
       end
 
@@ -921,9 +921,7 @@ def handle_private_class_method(node)
         entries = @index.resolve_method(name, @index.existing_or_new_singleton_class(owner_name).name)
         next unless entries
 
-        entries.each do |entry|
-          entry.visibility = Entry::Visibility::PRIVATE
-        end
+        entries.each { |entry| entry.visibility = :private }
       end
     end
 
@@ -1037,7 +1035,7 @@ def last_name_in_stack
       name.split("::").last
     end
 
-    #: (Prism::CallNode, Entry::Visibility) -> void
+    #: (Prism::CallNode, Symbol) -> void
     def handle_visibility_change(node, visibility)
       owner  = @owner_stack.last
       return unless owner

lib/ruby_indexer/lib/ruby_indexer/entry.rb

@@ -3,14 +3,6 @@
 
 module RubyIndexer
   class Entry
-    class Visibility < T::Enum
-      enums do
-        PUBLIC = new(:public)
-        PROTECTED = new(:protected)
-        PRIVATE = new(:private)
-      end
-    end
-
     #: String
     attr_reader :name
 
@@ -22,31 +14,31 @@ class Visibility < T::Enum
 
     alias_method :name_location, :location
 
-    #: Visibility
+    #: Symbol
     attr_accessor :visibility
 
     #: (String name, URI::Generic uri, Location location, String? comments) -> void
     def initialize(name, uri, location, comments)
       @name = name
       @uri = uri
       @comments = comments
-      @visibility = Visibility::PUBLIC #: Visibility
+      @visibility = :public #: Symbol
       @location = location
     end
 
     #: -> bool
     def public?
-      visibility == Visibility::PUBLIC
+      @visibility == :public
     end
 
     #: -> bool
     def protected?
-      visibility == Visibility::PROTECTED
+      @visibility == :protected
     end
 
     #: -> bool
     def private?
-      visibility == Visibility::PRIVATE
+      @visibility == :private
     end
 
     #: -> String
@@ -306,7 +298,7 @@ class Member < Entry
       #: Entry::Namespace?
       attr_reader :owner
 
-      #: (String name, URI::Generic uri, Location location, String? comments, Visibility visibility, Entry::Namespace? owner) -> void
+      #: (String name, URI::Generic uri, Location location, String? comments, Symbol visibility, Entry::Namespace? owner) -> void
       def initialize(name, uri, location, comments, visibility, owner) # rubocop:disable Metrics/ParameterLists
         super(name, uri, location, comments)
         @visibility = visibility
@@ -358,7 +350,7 @@ class Method < Member
       #: Location
       attr_reader :name_location
 
-      #: (String name, URI::Generic uri, Location location, Location name_location, String? comments, Array[Signature] signatures, Visibility visibility, Entry::Namespace? owner) -> void
+      #: (String name, URI::Generic uri, Location location, Location name_location, String? comments, Array[Signature] signatures, Symbol visibility, Entry::Namespace? owner) -> void
       def initialize(name, uri, location, name_location, comments, signatures, visibility, owner) # rubocop:disable Metrics/ParameterLists
         super(name, uri, location, comments, visibility, owner)
         @signatures = signatures

lib/ruby_indexer/lib/ruby_indexer/rbs_indexer.rb

@@ -107,15 +107,6 @@ def handle_method(member, owner)
       location = to_ruby_indexer_location(member.location)
       comments = comments_to_string(member)
 
-      visibility = case member.visibility
-      when :private
-        Entry::Visibility::PRIVATE
-      when :protected
-        Entry::Visibility::PROTECTED
-      else
-        Entry::Visibility::PUBLIC
-      end
-
       real_owner = member.singleton? ? @index.existing_or_new_singleton_class(owner.name) : owner
       signatures = signatures(member)
       @index.add(Entry::Method.new(
@@ -125,7 +116,7 @@ def handle_method(member, owner)
         location,
         comments,
         signatures,
-        visibility,
+        member.visibility || :public,
         real_owner,
       ))
     end

lib/ruby_indexer/lib/ruby_indexer/visibility_scope.rb

@@ -8,7 +8,7 @@ class VisibilityScope
     class << self
       #: -> instance
       def module_function_scope
-        new(module_func: true, visibility: Entry::Visibility::PRIVATE)
+        new(module_func: true, visibility: :private)
       end
 
       #: -> instance
@@ -17,14 +17,14 @@ def public_scope
       end
     end
 
-    #: Entry::Visibility
+    #: Symbol
     attr_reader :visibility
 
     #: bool
     attr_reader :module_func
 
-    #: (?visibility: Entry::Visibility, ?module_func: bool) -> void
-    def initialize(visibility: Entry::Visibility::PUBLIC, module_func: false)
+    #: (?visibility: Symbol, ?module_func: bool) -> void
+    def initialize(visibility: :public, module_func: false)
       @visibility = visibility
       @module_func = module_func
     end

lib/ruby_indexer/test/method_test.rb

@@ -100,9 +100,9 @@ def baz; end
         end
       RUBY
 
-      assert_entry("foo", Entry::Method, "/fake/path/foo.rb:1-10:2-5", visibility: Entry::Visibility::PRIVATE)
-      assert_entry("bar", Entry::Method, "/fake/path/foo.rb:4-2:4-14", visibility: Entry::Visibility::PUBLIC)
-      assert_entry("baz", Entry::Method, "/fake/path/foo.rb:8-2:8-14", visibility: Entry::Visibility::PROTECTED)
+      assert_entry("foo", Entry::Method, "/fake/path/foo.rb:1-10:2-5", visibility: :private)
+      assert_entry("bar", Entry::Method, "/fake/path/foo.rb:4-2:4-14", visibility: :public)
+      assert_entry("baz", Entry::Method, "/fake/path/foo.rb:8-2:8-14", visibility: :protected)
     end
 
     def test_visibility_tracking_with_nested_class_or_modules
@@ -120,9 +120,9 @@ def baz; end
         end
       RUBY
 
-      assert_entry("foo", Entry::Method, "/fake/path/foo.rb:3-2:3-14", visibility: Entry::Visibility::PRIVATE)
-      assert_entry("bar", Entry::Method, "/fake/path/foo.rb:6-4:6-16", visibility: Entry::Visibility::PUBLIC)
-      assert_entry("baz", Entry::Method, "/fake/path/foo.rb:9-2:9-14", visibility: Entry::Visibility::PRIVATE)
+      assert_entry("foo", Entry::Method, "/fake/path/foo.rb:3-2:3-14", visibility: :private)
+      assert_entry("bar", Entry::Method, "/fake/path/foo.rb:6-4:6-16", visibility: :public)
+      assert_entry("baz", Entry::Method, "/fake/path/foo.rb:9-2:9-14", visibility: :private)
     end
 
     def test_visibility_tracking_with_module_function
@@ -147,7 +147,7 @@ def bar; end
         # The second entry points to the public singleton method
         assert_equal("Test::<Class:Test>", second_entry&.owner&.name)
         assert_instance_of(Entry::SingletonClass, second_entry&.owner)
-        assert_equal(Entry::Visibility::PUBLIC, second_entry&.visibility)
+        assert_equal(:public, second_entry&.visibility)
       end
     end
 

lib/ruby_indexer/test/rbs_indexer_test.rb

@@ -60,7 +60,7 @@ def test_index_methods
       entry = entries.find { |entry| entry.owner&.name == "Array" } #: as Entry::Method
       assert_match(%r{/gems/rbs-.*/core/array.rbs}, entry.file_path)
       assert_equal("array.rbs", entry.file_name)
-      assert_equal(Entry::Visibility::PUBLIC, entry.visibility)
+      assert_equal(:public, entry.visibility)
 
       # Using fixed positions would be fragile, so let's just check some basics.
       assert_operator(entry.location.start_line, :>, 0)

lib/ruby_indexer/test/test_case.rb

@@ -11,6 +11,13 @@ def setup
       @default_indexed_entries = @index.instance_variable_get(:@entries).dup
     end
 
+    def teardown
+      entries = @index.instance_variable_get(:@entries).values.flatten
+      entries.each do |entry|
+        assert_includes([:public, :private, :protected], entry.visibility)
+      end
+    end
+
     private
 
     def index(source, uri: URI::Generic.from_path(path: "/fake/path/foo.rb"))
@@ -31,7 +38,6 @@ def assert_entry(expected_name, type, expected_location, visibility: nil)
           ":#{location.end_line - 1}-#{location.end_column}"
 
       assert_equal(expected_location, location_string)
-
       assert_equal(visibility, entry.visibility) if visibility
     end
 

lib/ruby_lsp/listeners/completion.rb

@@ -512,7 +512,7 @@ def complete_methods(node, name)
         external_references = @node_context.fully_qualified_name != type.name
 
         @index.method_completion_candidates(method_name, type.name).each do |entry|
-          next if entry.visibility != RubyIndexer::Entry::Visibility::PUBLIC && external_references
+          next if entry.visibility != :public && external_references
 
           entry_name = entry.name
           owner_name = entry.owner&.name