ruby-lsp 0.23.16 → 0.23.17

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6c17ad9bdfcbd63ad18912cd0247475f9a0b3739dd6ffae489a72d0d2b4b1d77
-  data.tar.gz: 3681e153bac6f08236fbd1f875a6fbafbb4c523af187f7471c798be8d3d40b7b
+  metadata.gz: 783a43ad6688b46f4edcb4662a06d9fa9277ecc35475e64189c02547ab4f980b
+  data.tar.gz: 3f4b78c3f7909886d8642d7608d4ef7d358c41ca55fa118380fa2082119864ff
 SHA512:
-  metadata.gz: 669a6d69961413145b35aec0d81dbcb0507e1d856f4534c70af38946dd43e9ee6f20a07fcb44e5f3ff7515de8ac47546d95ff7542a8756ce9b693ad35b70f20e
-  data.tar.gz: 11d7d9dd59c2cb216b49c5cc3ec7fa2cc1eda781a6394185fec614f287b0f707a363fc49aa3700cea7659c1735ea447a0d5c96d0ea81944eff96ae41c9fb4cda
+  metadata.gz: cb4be502edd93cd9ce01b505486f035733927076138447bd30607dda326bb40432c1ce0c8c50751252acf5098fbed24824a2c7e578b9914206411cbb7e869268
+  data.tar.gz: ce0ec2cdf2311ae7fda5c5c53fd3abcc122a7c6bcf031dd2dd30d8d65555e51e722985fbc58f75cce94b8591e36f6e404283f67d17c8ad58438c8ba5d7b82b39

data/VERSION

@@ -1 +1 @@
-0.23.16
+0.23.17

data/lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb

@@ -132,7 +132,7 @@ module RubyIndexer
         name = (expression.is_a?(Prism::SelfNode) ? "<Class:#{last_name_in_stack}>" : "<Class:#{expression.slice}>")
         real_nesting = Index.actual_nesting(@stack, name)
 
-        existing_entries = T.cast(@index[real_nesting.join("::")], T.nilable(T::Array[Entry::SingletonClass]))
+        existing_entries = @index[real_nesting.join("::")] #: as Array[Entry::SingletonClass]?
 
         if existing_entries
           entry = existing_entries.first #: as !nil
@@ -265,11 +265,11 @@ module RubyIndexer
       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 @@ module RubyIndexer
             name_location,
             comments,
             signatures,
-            Entry::Visibility::PUBLIC,
+            :public,
             singleton,
           ))
         end
@@ -465,8 +465,8 @@ module RubyIndexer
       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 @@ module RubyIndexer
       # 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 @@ module RubyIndexer
           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 @@ module RubyIndexer
             location,
             collect_comments(node)&.concat(entry.comments),
             entry.signatures,
-            Entry::Visibility::PUBLIC,
+            :public,
             singleton,
           ))
         end
@@ -894,7 +894,7 @@ module RubyIndexer
       # 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
 
@@ -903,10 +903,9 @@ module RubyIndexer
 
       # private_class_method accepts strings, symbols or arrays of strings and symbols as arguments. Here we build a
       # single list of all of the method names that have to be made private
-      arrays, others = T.cast(
-        arguments.partition { |argument| argument.is_a?(Prism::ArrayNode) },
-        [T::Array[Prism::ArrayNode], T::Array[Prism::Node]],
-      )
+      arrays, others = arguments.partition do |argument|
+        argument.is_a?(Prism::ArrayNode)
+      end #: as [Array[Prism::ArrayNode], Array[Prism::Node]]
       arrays.each { |array| others.concat(array.elements) }
 
       names = others.filter_map do |argument|
@@ -922,9 +921,7 @@ module RubyIndexer
         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
 
@@ -1038,7 +1035,7 @@ module RubyIndexer
       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

data/lib/ruby_indexer/lib/ruby_indexer/enhancement.rb

@@ -3,7 +3,6 @@
 
 module RubyIndexer
   class Enhancement
-    extend T::Sig
     extend T::Helpers
 
     abstract!
@@ -11,8 +10,6 @@ module RubyIndexer
     @enhancements = [] #: Array[Class[Enhancement]]
 
     class << self
-      extend T::Sig
-
       #: (Class[Enhancement] child) -> void
       def inherited(child)
         @enhancements << child

data/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,7 +14,7 @@ module RubyIndexer
 
     alias_method :name_location, :location
 
-    #: Visibility
+    #: Symbol
     attr_accessor :visibility
 
     #: (String name, URI::Generic uri, Location location, String? comments) -> void
@@ -30,23 +22,23 @@ module RubyIndexer
       @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
@@ -107,7 +99,6 @@ module RubyIndexer
     end
 
     class ModuleOperation
-      extend T::Sig
       extend T::Helpers
 
       abstract!
@@ -125,7 +116,6 @@ module RubyIndexer
     class Prepend < ModuleOperation; end
 
     class Namespace < Entry
-      extend T::Sig
       extend T::Helpers
 
       abstract!
@@ -203,7 +193,6 @@ module RubyIndexer
 
     class Parameter
       extend T::Helpers
-      extend T::Sig
 
       abstract!
 
@@ -309,7 +298,7 @@ module RubyIndexer
       #: 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
@@ -361,7 +350,7 @@ module RubyIndexer
       #: 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
@@ -563,7 +552,8 @@ module RubyIndexer
         end
 
         keyword_hash_nodes, positional_args = arguments.partition { |arg| arg.is_a?(Prism::KeywordHashNode) }
-        keyword_args = T.cast(keyword_hash_nodes.first, T.nilable(Prism::KeywordHashNode))&.elements
+        keyword_args = keyword_hash_nodes.first #: as Prism::KeywordHashNode?
+          &.elements
         forwarding_arguments, positionals = positional_args.partition do |arg|
           arg.is_a?(Prism::ForwardingArgumentsNode)
         end

data/lib/ruby_indexer/lib/ruby_indexer/index.rb

@@ -36,12 +36,10 @@ module RubyIndexer
 
       # Returns the unresolved name for a constant reference including all parts of a constant path, or `nil` if the
       # constant contains dynamic or incomplete parts
-      #: ((Prism::ConstantPathNode | Prism::ConstantReadNode | Prism::ConstantPathTargetNode | Prism::CallNode | Prism::MissingNode) node) -> String?
+      #: (Prism::Node) -> String?
       def constant_name(node)
         case node
-        when Prism::CallNode, Prism::MissingNode
-          nil
-        else
+        when Prism::ConstantPathNode, Prism::ConstantReadNode, Prism::ConstantPathTargetNode
           node.full_name
         end
       rescue Prism::ConstantPathNode::DynamicPartsInConstantPathError,
@@ -60,7 +58,7 @@ module RubyIndexer
       @entries = {} #: Hash[String, Array[Entry]]
 
       # Holds all entries in the index using a prefix tree for searching based on prefixes to provide autocompletion
-      @entries_tree = PrefixTree[T::Array[Entry]].new #: PrefixTree[Array[Entry]]
+      @entries_tree = PrefixTree.new #: PrefixTree[Array[Entry]]
 
       # Holds references to where entries where discovered so that we can easily delete them
       # {
@@ -71,7 +69,7 @@ module RubyIndexer
       @uris_to_entries = {} #: Hash[String, Array[Entry]]
 
       # Holds all require paths for every indexed item so that we can provide autocomplete for requires
-      @require_paths_tree = PrefixTree[URI::Generic].new #: PrefixTree[URI::Generic]
+      @require_paths_tree = PrefixTree.new #: PrefixTree[URI::Generic]
 
       # Holds the linearized ancestors list for every namespace
       @ancestors = {} #: Hash[String, Array[String]]
@@ -147,7 +145,7 @@ module RubyIndexer
 
     # Searches for a constant based on an unqualified name and returns the first possible match regardless of whether
     # there are more possible matching entries
-    #: (String name) -> Array[(Entry::Namespace | Entry::ConstantAlias | Entry::UnresolvedConstantAlias | Entry::Constant)]?
+    #: (String name) -> Array[Entry::Constant | Entry::ConstantAlias | Entry::Namespace | Entry::UnresolvedConstantAlias]?
     def first_unqualified_const(name)
       # Look for an exact match first
       _name, entries = @entries.find do |const_name, _entries|
@@ -161,15 +159,7 @@ module RubyIndexer
         end
       end
 
-      T.cast(
-        entries,
-        T.nilable(T::Array[T.any(
-          Entry::Namespace,
-          Entry::ConstantAlias,
-          Entry::UnresolvedConstantAlias,
-          Entry::Constant,
-        )]),
-      )
+      entries #: as Array[Entry::Constant | Entry::ConstantAlias | Entry::Namespace | Entry::UnresolvedConstantAlias]?
     end
 
     # Searches entries in the index based on an exact prefix, intended for providing autocomplete. All possible matches
@@ -272,19 +262,11 @@ module RubyIndexer
       completion_items.values.map!(&:first)
     end
 
-    #: (String name, Array[String] nesting) -> Array[Array[(Entry::Constant | Entry::ConstantAlias | Entry::Namespace | Entry::UnresolvedConstantAlias)]]
+    #: (String name, Array[String] nesting) -> Array[Array[Entry::Constant | Entry::ConstantAlias | Entry::Namespace | Entry::UnresolvedConstantAlias]]
     def constant_completion_candidates(name, nesting)
       # If we have a top level reference, then we don't need to include completions inside the current nesting
       if name.start_with?("::")
-        return T.cast(
-          @entries_tree.search(name.delete_prefix("::")),
-          T::Array[T::Array[T.any(
-            Entry::Constant,
-            Entry::ConstantAlias,
-            Entry::Namespace,
-            Entry::UnresolvedConstantAlias,
-          )]],
-        )
+        return @entries_tree.search(name.delete_prefix("::")) #: as Array[Array[Entry::Constant | Entry::ConstantAlias | Entry::Namespace | Entry::UnresolvedConstantAlias]] # rubocop:disable Layout/LineLength
       end
 
       # Otherwise, we have to include every possible constant the user might be referring to. This is essentially the
@@ -310,15 +292,7 @@ module RubyIndexer
       # Top level constants
       entries.concat(@entries_tree.search(name))
       entries.uniq!
-      T.cast(
-        entries,
-        T::Array[T::Array[T.any(
-          Entry::Constant,
-          Entry::ConstantAlias,
-          Entry::Namespace,
-          Entry::UnresolvedConstantAlias,
-        )]],
-      )
+      entries #: as Array[Array[Entry::Constant | Entry::ConstantAlias | Entry::Namespace | Entry::UnresolvedConstantAlias]] # rubocop:disable Layout/LineLength
     end
 
     # Resolve a constant to its declaration based on its name and the nesting where the reference was found. Parameter
@@ -328,7 +302,7 @@ module RubyIndexer
     # nesting: the nesting structure where the reference was found (e.g.: ["Foo", "Bar"])
     # seen_names: this parameter should not be used by consumers of the api. It is used to avoid infinite recursion when
     # resolving circular references
-    #: (String name, Array[String] nesting, ?Array[String] seen_names) -> Array[(Entry::Namespace | Entry::ConstantAlias | Entry::UnresolvedConstantAlias)]?
+    #: (String name, Array[String] nesting, ?Array[String] seen_names) -> Array[Entry::Constant | Entry::ConstantAlias | Entry::Namespace | Entry::UnresolvedConstantAlias]?
     def resolve(name, nesting, seen_names = [])
       # If we have a top level reference, then we just search for it straight away ignoring the nesting
       if name.start_with?("::")
@@ -586,7 +560,7 @@ module RubyIndexer
     # and find inherited instance variables as well
     #: (String variable_name, String owner_name) -> Array[Entry::InstanceVariable]?
     def resolve_instance_variable(variable_name, owner_name)
-      entries = T.cast(self[variable_name], T.nilable(T::Array[Entry::InstanceVariable]))
+      entries = self[variable_name] #: as Array[Entry::InstanceVariable]?
       return unless entries
 
       ancestors = linearized_ancestors_of(owner_name)
@@ -610,7 +584,7 @@ module RubyIndexer
     # include the `@` prefix
     #: (String name, String owner_name) -> Array[(Entry::InstanceVariable | Entry::ClassVariable)]
     def instance_variable_completion_candidates(name, owner_name)
-      entries = T.cast(prefix_search(name).flatten, T::Array[T.any(Entry::InstanceVariable, Entry::ClassVariable)])
+      entries = prefix_search(name).flatten #: as Array[Entry::InstanceVariable | Entry::ClassVariable]
       # Avoid wasting time linearizing ancestors if we didn't find anything
       return entries if entries.empty?
 
@@ -640,7 +614,7 @@ module RubyIndexer
 
     #: (String name, String owner_name) -> Array[Entry::ClassVariable]
     def class_variable_completion_candidates(name, owner_name)
-      entries = T.cast(prefix_search(name).flatten, T::Array[Entry::ClassVariable])
+      entries = prefix_search(name).flatten #: as Array[Entry::ClassVariable]
       # Avoid wasting time linearizing ancestors if we didn't find anything
       return entries if entries.empty?
 
@@ -676,15 +650,13 @@ module RubyIndexer
       # indirect means like including a module that than includes the ancestor. Trying to figure out exactly which
       # ancestors need to be deleted is too expensive. Therefore, if any of the namespace entries has a change to their
       # ancestor hash, we clear all ancestors and start linearizing lazily again from scratch
-      original_map = T.cast(
-        original_entries.select { |e| e.is_a?(Entry::Namespace) },
-        T::Array[Entry::Namespace],
-      ).to_h { |e| [e.name, e.ancestor_hash] }
+      original_map = original_entries
+        .select { |e| e.is_a?(Entry::Namespace) } #: as Array[Entry::Namespace]
+        .to_h { |e| [e.name, e.ancestor_hash] }
 
-      updated_map = T.cast(
-        updated_entries.select { |e| e.is_a?(Entry::Namespace) },
-        T::Array[Entry::Namespace],
-      ).to_h { |e| [e.name, e.ancestor_hash] }
+      updated_map = updated_entries
+        .select { |e| e.is_a?(Entry::Namespace) } #: as Array[Entry::Namespace]
+        .to_h { |e| [e.name, e.ancestor_hash] }
 
       @ancestors.clear if original_map.any? { |name, hash| updated_map[name] != hash }
     end
@@ -713,7 +685,7 @@ module RubyIndexer
     def existing_or_new_singleton_class(name)
       *_namespace, unqualified_name = name.split("::")
       full_singleton_name = "#{name}::<Class:#{unqualified_name}>"
-      singleton = T.cast(self[full_singleton_name]&.first, T.nilable(Entry::SingletonClass))
+      singleton = self[full_singleton_name]&.first #: as Entry::SingletonClass?
 
       unless singleton
         attached_ancestor = self[name]&.first #: as !nil
@@ -841,14 +813,11 @@ module RubyIndexer
     )
       # Find the first class entry that has a parent class. Notice that if the developer makes a mistake and inherits
       # from two different classes in different files, we simply ignore it
-      superclass = T.cast(
-        if singleton_levels > 0
-          self[attached_class_name]&.find { |n| n.is_a?(Entry::Class) && n.parent_class }
-        else
-          namespace_entries.find { |n| n.is_a?(Entry::Class) && n.parent_class }
-        end,
-        T.nilable(Entry::Class),
-      )
+      superclass = if singleton_levels > 0
+        self[attached_class_name]&.find { |n| n.is_a?(Entry::Class) && n.parent_class }
+      else
+        namespace_entries.find { |n| n.is_a?(Entry::Class) && n.parent_class }
+      end #: as Entry::Class?
 
       if superclass
         # If the user makes a mistake and creates a class that inherits from itself, this method would throw a stack
@@ -882,7 +851,7 @@ module RubyIndexer
       elsif singleton_levels > 0
         # When computing the linearization for a module's singleton class, it inherits from the linearized ancestors of
         # the `Module` class
-        mod = T.cast(self[attached_class_name]&.find { |n| n.is_a?(Entry::Module) }, T.nilable(Entry::Module))
+        mod = self[attached_class_name]&.find { |n| n.is_a?(Entry::Module) } #: as Entry::Module?
 
         if mod
           module_class_name_parts = ["Module"]
@@ -922,7 +891,7 @@ module RubyIndexer
       resolved_alias
     end
 
-    #: (String name, Array[String] nesting, Array[String] seen_names) -> Array[(Entry::Namespace | Entry::ConstantAlias | Entry::UnresolvedConstantAlias)]?
+    #: (String name, Array[String] nesting, Array[String] seen_names) -> Array[Entry::Constant | Entry::ConstantAlias | Entry::Namespace | Entry::UnresolvedConstantAlias]?
     def lookup_enclosing_scopes(name, nesting, seen_names)
       nesting.length.downto(1) do |i|
         namespace = nesting[0...i] #: as !nil
@@ -942,7 +911,7 @@ module RubyIndexer
       nil
     end
 
-    #: (String name, Array[String] nesting, Array[String] seen_names) -> Array[(Entry::Namespace | Entry::ConstantAlias | Entry::UnresolvedConstantAlias)]?
+    #: (String name, Array[String] nesting, Array[String] seen_names) -> Array[Entry::Constant | Entry::ConstantAlias | Entry::Namespace | Entry::UnresolvedConstantAlias]?
     def lookup_ancestor_chain(name, nesting, seen_names)
       *nesting_parts, constant_name = build_non_redundant_full_name(name, nesting).split("::")
       return if nesting_parts.empty?
@@ -1027,18 +996,13 @@ module RubyIndexer
       name_parts.join("::")
     end
 
-    #: (String full_name, Array[String] seen_names) -> Array[(Entry::Namespace | Entry::ConstantAlias | Entry::UnresolvedConstantAlias)]?
+    #: (String full_name, Array[String] seen_names) -> Array[Entry::Constant | Entry::ConstantAlias | Entry::Namespace | Entry::UnresolvedConstantAlias]?
     def direct_or_aliased_constant(full_name, seen_names)
       entries = @entries[full_name] || @entries[follow_aliased_namespace(full_name)]
 
-      T.cast(
-        entries&.map { |e| e.is_a?(Entry::UnresolvedConstantAlias) ? resolve_alias(e, seen_names) : e },
-        T.nilable(T::Array[T.any(
-          Entry::Namespace,
-          Entry::ConstantAlias,
-          Entry::UnresolvedConstantAlias,
-        )]),
-      )
+      entries&.map do |e|
+        e.is_a?(Entry::UnresolvedConstantAlias) ? resolve_alias(e, seen_names) : e
+      end #: as Array[Entry::Constant | Entry::ConstantAlias | Entry::Namespace | Entry::UnresolvedConstantAlias])?
     end
 
     # Attempt to resolve a given unresolved method alias. This method returns the resolved alias if we managed to

data/lib/ruby_indexer/lib/ruby_indexer/rbs_indexer.rb

@@ -107,15 +107,6 @@ module RubyIndexer
       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 @@ module RubyIndexer
         location,
         comments,
         signatures,
-        visibility,
+        member.visibility || :public,
         real_owner,
       ))
     end

data/lib/ruby_indexer/lib/ruby_indexer/visibility_scope.rb

@@ -8,7 +8,7 @@ module RubyIndexer
     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 @@ module RubyIndexer
       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

data/lib/ruby_indexer/test/index_test.rb

@@ -2185,6 +2185,13 @@ module RubyIndexer
 
       node = Prism.parse("class Foo; end").value.statements.body.first.constant_path
       assert_equal("Foo", Index.constant_name(node))
+
+      node = Prism.parse(<<~RUBY).value.statements.body.first.constant_path
+        class class Foo
+        end
+        end
+      RUBY
+      assert_nil(Index.constant_name(node))
     end
   end
 end

data/lib/ruby_indexer/test/method_test.rb

@@ -100,9 +100,9 @@ module RubyIndexer
         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 @@ module RubyIndexer
         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 @@ module RubyIndexer
         # 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
 

data/lib/ruby_indexer/test/rbs_indexer_test.rb

@@ -60,7 +60,7 @@ module RubyIndexer
       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)
@@ -373,8 +373,9 @@ module RubyIndexer
       pathname = Pathname.new("/file.rbs")
       indexer.process_signature(pathname, declarations)
       entry = index[method_name] #: as !nil
-        .first
-      T.cast(entry, Entry::Method).signatures
+        .first #: as Entry::Method
+
+      entry.signatures
     end
   end
 end

data/lib/ruby_indexer/test/test_case.rb

@@ -11,6 +11,13 @@ module RubyIndexer
       @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 @@ module RubyIndexer
           ":#{location.end_line - 1}-#{location.end_column}"
 
       assert_equal(expected_location, location_string)
-
       assert_equal(visibility, entry.visibility) if visibility
     end
 

data/lib/ruby_lsp/document.rb

@@ -3,14 +3,6 @@
 
 module RubyLsp
   class Document
-    class LanguageId < T::Enum
-      enums do
-        Ruby = new("ruby")
-        ERB = new("erb")
-        RBS = new("rbs")
-      end
-    end
-
     extend T::Sig
     extend T::Helpers
     extend T::Generic
@@ -71,7 +63,7 @@ module RubyLsp
       self.class == other.class && uri == other.uri && @source == other.source
     end
 
-    sig { abstract.returns(LanguageId) }
+    sig { abstract.returns(Symbol) }
     def language_id; end
 
     #: [T] (String request_name) { (Document[ParseResultType] document) -> T } -> T

data/lib/ruby_lsp/erb_document.rb

@@ -46,9 +46,9 @@ module RubyLsp
     end
 
     # @override
-    #: -> LanguageId
+    #: -> Symbol
     def language_id
-      LanguageId::ERB
+      :erb
     end
 
     #: (Hash[Symbol, untyped] position, ?node_types: Array[singleton(Prism::Node)]) -> NodeContext