ruby-lsp 0.17.1 → 0.17.3

data/lib/ruby_indexer/test/index_test.rb

@@ -107,16 +107,16 @@ module RubyIndexer
       RUBY
 
       result = @index.fuzzy_search("Bar")
-      assert_equal(1, result.length)
-      assert_equal(@index["Bar"].first, result.first)
+      assert_equal(3, result.length)
+      assert_equal(["Bar", "Backtrace", "Base"], result.map(&:name))
 
       result = @index.fuzzy_search("foobarsomeking")
-      assert_equal(5, result.length)
-      assert_equal(["Foo::Baz::Something", "Foo::Bar", "Foo::Baz", "Foo", "Bar"], result.map(&:name))
+      assert_equal(6, result.length)
+      assert_equal(["Foo::Baz::Something", "Foo::Bar", "Foo::Baz", "Foo", "Base", "Bar"], result.map(&:name))
 
       result = @index.fuzzy_search("FooBaz")
-      assert_equal(4, result.length)
-      assert_equal(["Foo::Baz", "Foo::Bar", "Foo", "Foo::Baz::Something"], result.map(&:name))
+      assert_equal(5, result.length)
+      assert_equal(["Foo::Baz", "Foo::Bar", "Foo", "Foo::Baz::Something", "Float"], result.map(&:name))
     end
 
     def test_index_single_ignores_directories
@@ -140,6 +140,8 @@ module RubyIndexer
     end
 
     def test_searching_for_entries_based_on_prefix
+      # For this test, it's easier if we don't include core classes and modules
+      @index = Index.new
       @index.index_single(IndexablePath.new("/fake", "/fake/path/foo.rb"), <<~RUBY)
         class Foo::Bar
         end
@@ -181,6 +183,9 @@ module RubyIndexer
 
     def test_resolving_aliases_to_non_existing_constants_with_conflicting_names
       @index.index_single(IndexablePath.new("/fake", "/fake/path/foo.rb"), <<~RUBY)
+        class Float
+        end
+
         module Foo
           class Float < self
             INFINITY = ::Float::INFINITY
@@ -315,7 +320,8 @@ module RubyIndexer
 
     def test_index_single_does_not_fail_for_non_existing_file
       @index.index_single(IndexablePath.new(nil, "/fake/path/foo.rb"))
-      assert_empty(@index.instance_variable_get(:@entries))
+      entries_after_indexing = @index.instance_variable_get(:@entries).keys
+      assert_equal(@default_indexed_entries.keys, entries_after_indexing)
     end
 
     def test_linearized_ancestors_basic_ordering
@@ -339,9 +345,9 @@ module RubyIndexer
           "B",
           "A",
           "Foo",
-          # "Object",
-          # "Kernel",
-          # "BasicObject",
+          "Object",
+          "Kernel",
+          "BasicObject",
         ],
         @index.linearized_ancestors_of("Foo"),
       )
@@ -351,9 +357,9 @@ module RubyIndexer
           "Bar",
           "B",
           "A",
-          # "Object",
-          # "Kernel",
-          # "BasicObject",
+          "Object",
+          "Kernel",
+          "BasicObject",
         ],
         @index.linearized_ancestors_of("Bar"),
       )
@@ -401,9 +407,9 @@ module RubyIndexer
           "A",
           "C",
           "Bar",
-          # "Object",
-          # "Kernel",
-          # "BasicObject",
+          "Object",
+          "Kernel",
+          "BasicObject",
         ],
         @index.linearized_ancestors_of("Foo"),
       )
@@ -432,9 +438,9 @@ module RubyIndexer
           "Foo",
           "B",
           "A",
-          # "Object",
-          # "Kernel",
-          # "BasicObject",
+          "Object",
+          "Kernel",
+          "BasicObject",
         ],
         @index.linearized_ancestors_of("Foo"),
       )
@@ -444,9 +450,9 @@ module RubyIndexer
           "B",
           "A",
           "Bar",
-          # "Object",
-          # "Kernel",
-          # "BasicObject",
+          "Object",
+          "Kernel",
+          "BasicObject",
         ],
         @index.linearized_ancestors_of("Bar"),
       )
@@ -493,9 +499,9 @@ module RubyIndexer
         [
           "A",
           "Foo",
-          # "Object",
-          # "Kernel",
-          # "BasicObject",
+          "Object",
+          "Kernel",
+          "BasicObject",
         ],
         @index.linearized_ancestors_of("Foo"),
       )
@@ -505,9 +511,9 @@ module RubyIndexer
           "A",
           "Bar",
           "A",
-          # "Object",
-          # "Kernel",
-          # "BasicObject",
+          "Object",
+          "Kernel",
+          "BasicObject",
         ],
         @index.linearized_ancestors_of("Bar"),
       )
@@ -519,15 +525,7 @@ module RubyIndexer
         end
       RUBY
 
-      assert_equal(
-        [
-          "Foo",
-          # "Object",
-          # "Kernel",
-          # "BasicObject",
-        ],
-        @index.linearized_ancestors_of("Foo"),
-      )
+      assert_equal(["Foo"], @index.linearized_ancestors_of("Foo"))
     end
 
     def test_ancestors_linearization_complex_prepend_duplication
@@ -552,9 +550,9 @@ module RubyIndexer
           "B",
           "C",
           "Foo",
-          # "Object",
-          # "Kernel",
-          # "BasicObject",
+          "Object",
+          "Kernel",
+          "BasicObject",
         ],
         @index.linearized_ancestors_of("Foo"),
       )
@@ -582,9 +580,9 @@ module RubyIndexer
           "C",
           "B",
           "A",
-          # "Object",
-          # "Kernel",
-          # "BasicObject",
+          "Object",
+          "Kernel",
+          "BasicObject",
         ],
         @index.linearized_ancestors_of("Foo"),
       )
@@ -613,9 +611,9 @@ module RubyIndexer
           "Foo::Bar",
           "Foo::Baz",
           "Foo::Something",
-          # "Object",
-          # "Kernel",
-          # "BasicObject",
+          "Object",
+          "Kernel",
+          "BasicObject",
         ],
         @index.linearized_ancestors_of("Foo::Bar"),
       )
@@ -623,9 +621,7 @@ module RubyIndexer
 
     def test_linearizing_ancestors_for_non_existing_namespaces
       index(<<~RUBY)
-        module Kernel
-          def Array(a); end
-        end
+        def Bar(a); end
       RUBY
 
       assert_raises(Index::NonExistingNamespaceError) do
@@ -633,7 +629,7 @@ module RubyIndexer
       end
 
       assert_raises(Index::NonExistingNamespaceError) do
-        @index.linearized_ancestors_of("Array")
+        @index.linearized_ancestors_of("Bar")
       end
     end
 
@@ -754,7 +750,7 @@ module RubyIndexer
           indexable_path = IndexablePath.new(nil, File.join(dir, "foo.rb"))
           @index.index_single(indexable_path)
 
-          assert_equal(["Bar", "Foo"], @index.linearized_ancestors_of("Bar"))
+          assert_equal(["Bar", "Foo", "Object", "Kernel", "BasicObject"], @index.linearized_ancestors_of("Bar"))
 
           # Remove include to invalidate the ancestor tree
           File.write(File.join(dir, "foo.rb"), <<~RUBY)
@@ -767,7 +763,7 @@ module RubyIndexer
 
           @index.handle_change(indexable_path)
           assert_empty(@index.instance_variable_get(:@ancestors))
-          assert_equal(["Bar"], @index.linearized_ancestors_of("Bar"))
+          assert_equal(["Bar", "Object", "Kernel", "BasicObject"], @index.linearized_ancestors_of("Bar"))
         end
       end
     end
@@ -788,7 +784,7 @@ module RubyIndexer
           indexable_path = IndexablePath.new(nil, File.join(dir, "foo.rb"))
           @index.index_single(indexable_path)
 
-          assert_equal(["Bar", "Foo"], @index.linearized_ancestors_of("Bar"))
+          assert_equal(["Bar", "Foo", "Object", "Kernel", "BasicObject"], @index.linearized_ancestors_of("Bar"))
 
           # Remove include to invalidate the ancestor tree
           File.write(File.join(dir, "foo.rb"), <<~RUBY)
@@ -804,7 +800,7 @@ module RubyIndexer
 
           @index.handle_change(indexable_path)
           refute_empty(@index.instance_variable_get(:@ancestors))
-          assert_equal(["Bar", "Foo"], @index.linearized_ancestors_of("Bar"))
+          assert_equal(["Bar", "Foo", "Object", "Kernel", "BasicObject"], @index.linearized_ancestors_of("Bar"))
         end
       end
     end
@@ -824,7 +820,7 @@ module RubyIndexer
           indexable_path = IndexablePath.new(nil, File.join(dir, "foo.rb"))
           @index.index_single(indexable_path)
 
-          assert_equal(["Bar", "Foo"], @index.linearized_ancestors_of("Bar"))
+          assert_equal(["Bar", "Foo", "Object", "Kernel", "BasicObject"], @index.linearized_ancestors_of("Bar"))
 
           # Remove include to invalidate the ancestor tree
           File.write(File.join(dir, "foo.rb"), <<~RUBY)
@@ -837,9 +833,345 @@ module RubyIndexer
 
           @index.handle_change(indexable_path)
           assert_empty(@index.instance_variable_get(:@ancestors))
-          assert_equal(["Bar"], @index.linearized_ancestors_of("Bar"))
+          assert_equal(["Bar", "Object", "Kernel", "BasicObject"], @index.linearized_ancestors_of("Bar"))
         end
       end
     end
+
+    def test_resolving_inherited_constants
+      index(<<~RUBY)
+        module Foo
+          CONST = 1
+        end
+
+        module Baz
+          CONST = 2
+        end
+
+        module Qux
+          include Foo
+        end
+
+        module Namespace
+          CONST = 3
+
+          include Baz
+
+          class Bar
+            include Qux
+          end
+        end
+
+        CONST = 4
+      RUBY
+
+      entry = T.must(@index.resolve("CONST", ["Namespace", "Bar"])&.first)
+      assert_equal(14, entry.location.start_line)
+    end
+
+    def test_resolving_inherited_alised_namespace
+      index(<<~RUBY)
+        module Bar
+          TARGET = 123
+        end
+
+        module Foo
+          CONST = Bar
+        end
+
+        module Namespace
+          class Bar
+            include Foo
+          end
+        end
+      RUBY
+
+      entry = T.must(@index.resolve("Foo::CONST::TARGET", [])&.first)
+      assert_equal(2, entry.location.start_line)
+
+      entry = T.must(@index.resolve("Namespace::Bar::CONST::TARGET", [])&.first)
+      assert_equal(2, entry.location.start_line)
+    end
+
+    def test_resolving_same_constant_from_different_scopes
+      index(<<~RUBY)
+        module Namespace
+          CONST = 123
+
+          class Parent
+            CONST = 321
+          end
+
+          class Child < Parent
+          end
+        end
+      RUBY
+
+      entry = T.must(@index.resolve("CONST", ["Namespace", "Child"])&.first)
+      assert_equal(2, entry.location.start_line)
+
+      entry = T.must(@index.resolve("Namespace::Child::CONST", [])&.first)
+      assert_equal(5, entry.location.start_line)
+    end
+
+    def test_resolving_prepended_constants
+      index(<<~RUBY)
+        module Included
+          CONST = 123
+        end
+
+        module Prepended
+          CONST = 321
+        end
+
+        class Foo
+          include Included
+          prepend Prepended
+        end
+
+        class Bar
+          CONST = 456
+          include Included
+          prepend Prepended
+        end
+      RUBY
+
+      entry = T.must(@index.resolve("CONST", ["Foo"])&.first)
+      assert_equal(6, entry.location.start_line)
+
+      entry = T.must(@index.resolve("Foo::CONST", [])&.first)
+      assert_equal(6, entry.location.start_line)
+
+      entry = T.must(@index.resolve("Bar::CONST", [])&.first)
+      assert_equal(15, entry.location.start_line)
+    end
+
+    def test_resolving_constants_favors_ancestors_over_top_level
+      index(<<~RUBY)
+        module Value1
+          CONST = 1
+        end
+
+        module Value2
+          CONST = 2
+        end
+
+        CONST = 3
+        module First
+          include Value1
+
+          module Second
+            include Value2
+          end
+        end
+      RUBY
+
+      entry = T.must(@index.resolve("CONST", ["First", "Second"])&.first)
+      assert_equal(6, entry.location.start_line)
+    end
+
+    def test_resolving_circular_alias
+      index(<<~RUBY)
+        module Namespace
+          FOO = BAR
+          BAR = FOO
+        end
+      RUBY
+
+      foo_entry = T.must(@index.resolve("FOO", ["Namespace"])&.first)
+      assert_equal(2, foo_entry.location.start_line)
+      assert_instance_of(Entry::Alias, foo_entry)
+
+      bar_entry = T.must(@index.resolve("BAR", ["Namespace"])&.first)
+      assert_equal(3, bar_entry.location.start_line)
+      assert_instance_of(Entry::Alias, bar_entry)
+    end
+
+    def test_resolving_circular_alias_three_levels
+      index(<<~RUBY)
+        module Namespace
+          FOO = BAR
+          BAR = BAZ
+          BAZ = FOO
+        end
+      RUBY
+
+      foo_entry = T.must(@index.resolve("FOO", ["Namespace"])&.first)
+      assert_equal(2, foo_entry.location.start_line)
+      assert_instance_of(Entry::Alias, foo_entry)
+
+      bar_entry = T.must(@index.resolve("BAR", ["Namespace"])&.first)
+      assert_equal(3, bar_entry.location.start_line)
+      assert_instance_of(Entry::Alias, bar_entry)
+
+      baz_entry = T.must(@index.resolve("BAZ", ["Namespace"])&.first)
+      assert_equal(4, baz_entry.location.start_line)
+      assert_instance_of(Entry::Alias, baz_entry)
+    end
+
+    def test_resolving_top_level_compact_reference
+      index(<<~RUBY)
+        class Foo::Bar
+        end
+      RUBY
+
+      foo_entry = T.must(@index.resolve("Foo::Bar", [])&.first)
+      assert_equal(1, foo_entry.location.start_line)
+      assert_instance_of(Entry::Class, foo_entry)
+    end
+
+    def test_resolving_references_with_redundant_namespaces
+      index(<<~RUBY)
+        module Bar
+          CONST = 1
+        end
+
+        module A
+          CONST = 2
+
+          module B
+            CONST = 3
+
+            class Foo
+              include Bar
+            end
+
+            A::B::Foo::CONST
+          end
+        end
+      RUBY
+
+      foo_entry = T.must(@index.resolve("A::B::Foo::CONST", ["A", "B"])&.first)
+      assert_equal(2, foo_entry.location.start_line)
+    end
+
+    def test_resolving_qualified_references
+      index(<<~RUBY)
+        module Namespace
+          class Entry
+            CONST = 1
+          end
+        end
+
+        module Namespace
+          class Index
+          end
+        end
+      RUBY
+
+      foo_entry = T.must(@index.resolve("Entry::CONST", ["Namespace", "Index"])&.first)
+      assert_equal(3, foo_entry.location.start_line)
+    end
+
+    def test_resolving_unqualified_references
+      index(<<~RUBY)
+        module Foo
+          CONST = 1
+        end
+
+        module Namespace
+          CONST = 2
+
+          class Index
+            include Foo
+          end
+        end
+      RUBY
+
+      foo_entry = T.must(@index.resolve("CONST", ["Namespace", "Index"])&.first)
+      assert_equal(6, foo_entry.location.start_line)
+    end
+
+    def test_resolving_references_with_only_top_level_declaration
+      index(<<~RUBY)
+        CONST = 1
+
+        module Foo; end
+
+        module Namespace
+          class Index
+            include Foo
+          end
+        end
+      RUBY
+
+      foo_entry = T.must(@index.resolve("CONST", ["Namespace", "Index"])&.first)
+      assert_equal(1, foo_entry.location.start_line)
+    end
+
+    def test_instance_variables_completions_from_different_owners_with_conflicting_names
+      index(<<~RUBY)
+        class Foo
+          def initialize
+            @bar = 1
+          end
+        end
+
+        class Bar
+          def initialize
+            @bar = 2
+          end
+        end
+      RUBY
+
+      entry = T.must(@index.instance_variable_completion_candidates("@", "Bar")&.first)
+      assert_equal("@bar", entry.name)
+      assert_equal("Bar", T.must(entry.owner).name)
+    end
+
+    def test_resolving_a_qualified_reference
+      index(<<~RUBY)
+        class Base
+          module Third
+            CONST = 1
+          end
+        end
+
+        class Foo
+          module Third
+            CONST = 2
+          end
+
+          class Second < Base
+          end
+        end
+      RUBY
+
+      foo_entry = T.must(@index.resolve("Third::CONST", ["Foo"])&.first)
+      assert_equal(9, foo_entry.location.start_line)
+    end
+
+    def test_resolving_unindexed_constant_with_no_nesting
+      assert_nil(@index.resolve("RSpec", []))
+    end
+
+    def test_object_superclass_resolution
+      @index.index_single(IndexablePath.new(nil, "/fake/path/foo.rb"), <<~RUBY)
+        module Foo
+          class Object; end
+
+          class Bar; end
+          class Baz < Object; end
+        end
+      RUBY
+
+      assert_equal(["Foo::Bar", "Object", "Kernel", "BasicObject"], @index.linearized_ancestors_of("Foo::Bar"))
+      assert_equal(
+        ["Foo::Baz", "Foo::Object", "Object", "Kernel", "BasicObject"],
+        @index.linearized_ancestors_of("Foo::Baz"),
+      )
+    end
+
+    def test_top_level_object_superclass_resolution
+      @index.index_single(IndexablePath.new(nil, "/fake/path/foo.rb"), <<~RUBY)
+        module Foo
+          class Object; end
+
+          class Bar < ::Object; end
+        end
+      RUBY
+
+      assert_equal(["Foo::Bar", "Object", "Kernel", "BasicObject"], @index.linearized_ancestors_of("Foo::Bar"))
+    end
   end
 end

data/lib/ruby_indexer/test/method_test.rb

@@ -378,5 +378,25 @@ module RubyIndexer
       entry = T.must(@index["third"]&.first)
       assert_equal("Foo", T.must(entry.owner).name)
     end
+
+    def test_keeps_track_of_aliases
+      index(<<~RUBY)
+        class Foo
+          alias whatever to_s
+          alias_method :foo, :to_a
+          alias_method "bar", "to_a"
+
+          # These two are not indexed because they are dynamic or incomplete
+          alias_method baz, :to_a
+          alias_method :baz
+        end
+      RUBY
+
+      assert_entry("whatever", Entry::UnresolvedMethodAlias, "/fake/path/foo.rb:1-8:1-16")
+      assert_entry("foo", Entry::UnresolvedMethodAlias, "/fake/path/foo.rb:2-15:2-19")
+      assert_entry("bar", Entry::UnresolvedMethodAlias, "/fake/path/foo.rb:3-15:3-20")
+      # Foo plus 3 valid aliases
+      assert_equal(4, @index.instance_variable_get(:@entries).length - @default_indexed_entries.length)
+    end
   end
 end

data/lib/ruby_indexer/test/rbs_indexer_test.rb

@@ -0,0 +1,42 @@
+# typed: true
+# frozen_string_literal: true
+
+require_relative "test_case"
+
+module RubyIndexer
+  class RBSIndexerTest < TestCase
+    def test_index_core_classes
+      entries = @index["Array"]
+      refute_nil(entries)
+      assert_equal(1, entries.length)
+      entry = entries.first
+      assert_match(%r{/gems/rbs-.*/core/array.rbs}, entry.file_path)
+      assert_equal("array.rbs", entry.file_name)
+      assert_equal("Object", entry.parent_class)
+      assert_equal(1, entry.mixin_operations.length)
+      enumerable_include = entry.mixin_operations.first
+      assert_equal("Enumerable", enumerable_include.module_name)
+
+      # Using fixed positions would be fragile, so let's just check some basics.
+      assert_operator(entry.location.start_line, :>, 0)
+      assert_operator(entry.location.end_line, :>, entry.location.start_line)
+      assert_equal(0, entry.location.start_column)
+      assert_operator(entry.location.end_column, :>, 0)
+    end
+
+    def test_index_core_modules
+      entries = @index["Kernel"]
+      refute_nil(entries)
+      assert_equal(1, entries.length)
+      entry = entries.first
+      assert_match(%r{/gems/rbs-.*/core/kernel.rbs}, entry.file_path)
+      assert_equal("kernel.rbs", entry.file_name)
+
+      # Using fixed positions would be fragile, so let's just check some basics.
+      assert_operator(entry.location.start_line, :>, 0)
+      assert_operator(entry.location.end_line, :>, entry.location.start_line)
+      assert_equal(0, entry.location.start_column)
+      assert_operator(entry.location.end_column, :>, 0)
+    end
+  end
+end

data/lib/ruby_indexer/test/test_case.rb

@@ -7,6 +7,8 @@ module RubyIndexer
   class TestCase < Minitest::Test
     def setup
       @index = Index.new
+      RBSIndexer.new(@index).index_ruby_core
+      @default_indexed_entries = @index.instance_variable_get(:@entries).dup
     end
 
     private
@@ -17,6 +19,7 @@ module RubyIndexer
 
     def assert_entry(expected_name, type, expected_location, visibility: nil)
       entries = @index[expected_name]
+      refute_nil(entries, "Expected #{expected_name} to be indexed")
       refute_empty(entries, "Expected #{expected_name} to be indexed")
 
       entry = entries.first
@@ -41,6 +44,10 @@ module RubyIndexer
       assert_empty(@index.instance_variable_get(:@entries), "Expected nothing to be indexed")
     end
 
+    def assert_no_indexed_entries
+      assert_equal(@default_indexed_entries, @index.instance_variable_get(:@entries))
+    end
+
     def assert_no_entry(entry)
       refute(@index.instance_variable_get(:@entries).key?(entry), "Expected '#{entry}' to not be indexed")
     end