Improve handling of class variables, aliases and constant aliases

Author: pkondzior

lib/ruby_indexer/lib/ruby_indexer/index.rb

@@ -198,13 +198,14 @@ def prefix_search(query, nesting = nil)
     #: (String? query) -> Array[Entry]
     def fuzzy_search(query)
       unless query
-        entries = @entries.filter_map do |_name, entries|
+        entries = @entries.values.filter_map do |entries|
           next if entries.first.is_a?(Entry::SingletonClass)
 
           entries
         end
-
-        return entries.flatten
+        return entries.flat_map do |entries|
+          skip_unresolved_entries(entries)
+        end
       end
 
       normalized_query = query.gsub("::", "").downcase
@@ -216,7 +217,9 @@ def fuzzy_search(query)
         [entries, -similarity] if similarity > ENTRY_SIMILARITY_THRESHOLD
       end
       results.sort_by!(&:last)
-      results.flat_map(&:first)
+      results.flat_map do |entries, _similarity|
+        skip_unresolved_entries(entries)
+      end
     end
 
     #: (String? name, String receiver_name) -> Array[(Entry::Member | Entry::MethodAlias)]
@@ -1054,5 +1057,34 @@ def resolve_method_alias(entry, receiver_name, seen_names)
       original_entries << resolved_alias
       resolved_alias
     end
+
+    # Attempts to resolve an entry if it is an unresolved constant or method alias.
+    # Returns the resolved entry, or nil if it cannot be resolved.
+    #: (Entry) -> Entry?
+    def resolve_entry(entry)
+      case entry
+      when Entry::UnresolvedConstantAlias
+        resolved_entry = resolve_alias(entry, [])
+        resolved_entry unless resolved_entry.is_a?(Entry::UnresolvedConstantAlias)
+      when Entry::UnresolvedMethodAlias
+        resolved_entry = resolve_method_alias(entry, entry.owner&.name || "", [])
+        resolved_entry unless resolved_entry.is_a?(Entry::UnresolvedMethodAlias)
+      else
+        entry
+      end
+    end
+
+    # Filters and resolves entries, skipping those that remain unresolved.
+    # Returns an array of successfully resolved entries.
+    #: (Array[Entry]) -> Array[Entry?]
+    def skip_unresolved_entries(entries)
+      entries.filter_map do |entry|
+        resolved_entry = resolve_entry(entry)
+
+        next unless resolved_entry
+
+        resolved_entry
+      end
+    end
   end
 end

lib/ruby_lsp/requests/support/common.rb

@@ -140,21 +140,28 @@ def each_constant_path_part(node, &block)
           end
         end
 
-        #: (RubyIndexer::Entry entry) -> Integer?
+        #: (RubyIndexer::Entry entry) -> Integer
         def kind_for_entry(entry)
           case entry
           when RubyIndexer::Entry::Class
             Constant::SymbolKind::CLASS
           when RubyIndexer::Entry::Module
             Constant::SymbolKind::NAMESPACE
-          when RubyIndexer::Entry::Constant
+          when RubyIndexer::Entry::Constant, RubyIndexer::Entry::ConstantAlias
             Constant::SymbolKind::CONSTANT
           when RubyIndexer::Entry::Method
             entry.name == "initialize" ? Constant::SymbolKind::CONSTRUCTOR : Constant::SymbolKind::METHOD
           when RubyIndexer::Entry::Accessor
             Constant::SymbolKind::PROPERTY
-          when RubyIndexer::Entry::InstanceVariable
+          when RubyIndexer::Entry::InstanceVariable, RubyIndexer::Entry::ClassVariable
             Constant::SymbolKind::FIELD
+          when RubyIndexer::Entry::MethodAlias
+            Constant::SymbolKind::METHOD
+          else
+            # Kind shold be represented by one of
+            # [SymbolKind](https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#symbolKind) variants
+            # $stderr.puts("Unknonw symbol kind #{entry.inspect}. Kind should be represented by one of SymbolKind enum variants. Please report this as a bug")
+            Constant::SymbolKind::NULL
           end
         end
       end

test/requests/workspace_symbol_test.rb

@@ -108,6 +108,61 @@ def bar; end
     assert_equal(RubyLsp::Constant::SymbolKind::PROPERTY, result&.kind)
   end
 
+  def test_returns_resolved_method_alias
+    @index.index_single(URI::Generic.from_path(path: "/fake.rb"), <<~RUBY)
+      class Foo
+        def test
+        end
+        alias whatever test
+        alias_method :bar, :to_a
+        alias_method "baz", "to_a"
+      end
+    RUBY
+
+    result = RubyLsp::Requests::WorkspaceSymbol.new(@global_state, "whatever").perform.first
+    assert_equal("whatever", result&.name)
+    assert_equal(RubyLsp::Constant::SymbolKind::METHOD, result&.kind)
+
+    result = RubyLsp::Requests::WorkspaceSymbol.new(@global_state, "bar").perform
+    assert_empty(result)
+
+    result = RubyLsp::Requests::WorkspaceSymbol.new(@global_state, "bag").perform
+    assert_empty(result)
+  end
+
+  def test_returns_resolved_constant_alias
+    @index.index_single(URI::Generic.from_path(path: "/fake.rb"), <<~RUBY)
+      OK = 'OK'
+      class Foo
+        BOK = OK
+        BAD = AD
+      end
+    RUBY
+
+    result = RubyLsp::Requests::WorkspaceSymbol.new(@global_state, "OK").perform.first
+    assert_equal("OK", result&.name)
+    assert_equal(RubyLsp::Constant::SymbolKind::CONSTANT, result&.kind)
+
+    result = RubyLsp::Requests::WorkspaceSymbol.new(@global_state, "Foo::OK").perform.first
+    assert_equal("Foo::BOK", result&.name)
+    assert_equal(RubyLsp::Constant::SymbolKind::CONSTANT, result&.kind)
+
+    result = RubyLsp::Requests::WorkspaceSymbol.new(@global_state, "BAD").perform
+    assert_empty(result)
+  end
+
+  def test_returns_class_variable
+    @index.index_single(URI::Generic.from_path(path: "/fake.rb"), <<~RUBY)
+      class Foo
+        @@test = '123'
+      end
+    RUBY
+
+    result = RubyLsp::Requests::WorkspaceSymbol.new(@global_state, "test").perform.first
+    assert_equal("@@test", result&.name)
+    assert_equal(RubyLsp::Constant::SymbolKind::FIELD, result&.kind)
+  end
+
   def test_returns_symbols_from_unsaved_files
     @index.index_single(URI("untitled:Untitled-1"), <<~RUBY)
       class Foo; end