ruby-lsp 0.17.3 → 0.17.5

data/lib/ruby_indexer/test/index_test.rb

@@ -93,30 +93,30 @@ module RubyIndexer
 
     def test_fuzzy_search
       @index.index_single(IndexablePath.new(nil, "/fake/path/foo.rb"), <<~RUBY)
-        class Bar; end
+        class Zws; end
 
-        module Foo
-          class Bar
+        module Qtl
+          class Zws
           end
 
-          class Baz
+          class Zwo
             class Something
             end
           end
         end
       RUBY
 
-      result = @index.fuzzy_search("Bar")
-      assert_equal(3, result.length)
-      assert_equal(["Bar", "Backtrace", "Base"], result.map(&:name))
-
-      result = @index.fuzzy_search("foobarsomeking")
-      assert_equal(6, result.length)
-      assert_equal(["Foo::Baz::Something", "Foo::Bar", "Foo::Baz", "Foo", "Base", "Bar"], result.map(&:name))
+      result = @index.fuzzy_search("Zws")
+      assert_equal(2, result.length)
+      assert_equal(["Zws", "Qtl::Zwo::Something"], result.map(&:name))
 
-      result = @index.fuzzy_search("FooBaz")
+      result = @index.fuzzy_search("qtlzwssomeking")
       assert_equal(5, result.length)
-      assert_equal(["Foo::Baz", "Foo::Bar", "Foo", "Foo::Baz::Something", "Float"], result.map(&:name))
+      assert_equal(["Qtl::Zwo::Something", "Qtl::Zws", "Qtl::Zwo", "Qtl", "Zws"], result.map(&:name))
+
+      result = @index.fuzzy_search("QltZwo")
+      assert_equal(4, result.length)
+      assert_equal(["Qtl::Zwo", "Qtl::Zws", "Qtl::Zwo::Something", "Qtl"], result.map(&:name))
     end
 
     def test_index_single_ignores_directories
@@ -140,25 +140,23 @@ 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
+        class Foo::Bizw
         end
       RUBY
       @index.index_single(IndexablePath.new("/fake", "/fake/path/other_foo.rb"), <<~RUBY)
-        class Foo::Bar
+        class Foo::Bizw
         end
 
-        class Foo::Baz
+        class Foo::Bizt
         end
       RUBY
 
       results = @index.prefix_search("Foo", []).map { |entries| entries.map(&:name) }
-      assert_equal([["Foo::Bar", "Foo::Bar"], ["Foo::Baz"]], results)
+      assert_equal([["Foo::Bizw", "Foo::Bizw"], ["Foo::Bizt"]], results)
 
-      results = @index.prefix_search("Ba", ["Foo"]).map { |entries| entries.map(&:name) }
-      assert_equal([["Foo::Bar", "Foo::Bar"], ["Foo::Baz"]], results)
+      results = @index.prefix_search("Biz", ["Foo"]).map { |entries| entries.map(&:name) }
+      assert_equal([["Foo::Bizw", "Foo::Bizw"], ["Foo::Bizt"]], results)
     end
 
     def test_resolve_normalizes_top_level_names
@@ -291,16 +289,16 @@ module RubyIndexer
       index(<<~RUBY)
         module Foo
           module Bar
-            def baz; end
+            def qzx; end
           end
         end
       RUBY
 
-      entries = @index.prefix_search("ba")
+      entries = @index.prefix_search("qz")
       refute_empty(entries)
 
-      entry = T.must(entries.first).first
-      assert_equal("baz", entry.name)
+      entry = T.must(T.must(entries.first).first)
+      assert_equal("qzx", entry.name)
     end
 
     def test_indexing_prism_fixtures_succeeds
@@ -315,12 +313,12 @@ module RubyIndexer
         @index.index_single(indexable_path)
       end
 
-      refute_empty(@index.instance_variable_get(:@entries))
+      refute_empty(@index)
     end
 
     def test_index_single_does_not_fail_for_non_existing_file
       @index.index_single(IndexablePath.new(nil, "/fake/path/foo.rb"))
-      entries_after_indexing = @index.instance_variable_get(:@entries).keys
+      entries_after_indexing = @index.names
       assert_equal(@default_indexed_entries.keys, entries_after_indexing)
     end
 
@@ -1009,6 +1007,43 @@ module RubyIndexer
       assert_instance_of(Entry::Alias, baz_entry)
     end
 
+    def test_resolving_constants_in_aliased_namespace
+      index(<<~RUBY)
+        module Original
+          module Something
+            CONST = 123
+          end
+        end
+
+        module Other
+          ALIAS = Original::Something
+        end
+
+        module Third
+          Other::ALIAS::CONST
+        end
+      RUBY
+
+      entry = T.must(@index.resolve("Other::ALIAS::CONST", ["Third"])&.first)
+      assert_kind_of(Entry::Constant, entry)
+      assert_equal("Original::Something::CONST", entry.name)
+    end
+
+    def test_resolving_top_level_aliases
+      index(<<~RUBY)
+        class Foo
+          CONST = 123
+        end
+
+        FOO = Foo
+        FOO::CONST
+      RUBY
+
+      entry = T.must(@index.resolve("FOO::CONST", [])&.first)
+      assert_kind_of(Entry::Constant, entry)
+      assert_equal("Foo::CONST", entry.name)
+    end
+
     def test_resolving_top_level_compact_reference
       index(<<~RUBY)
         class Foo::Bar
@@ -1145,8 +1180,32 @@ module RubyIndexer
       assert_nil(@index.resolve("RSpec", []))
     end
 
+    def test_object_superclass_indexing_and_resolution_with_reopened_object_class
+      index(<<~RUBY)
+        class Object; end
+      RUBY
+
+      entries = @index["Object"]
+      assert_equal(2, entries.length)
+      reopened_entry = entries.last
+      assert_equal("::BasicObject", reopened_entry.parent_class)
+      assert_equal(["Object", "Kernel", "BasicObject"], @index.linearized_ancestors_of("Object"))
+    end
+
+    def test_object_superclass_indexing_and_resolution_with_reopened_basic_object_class
+      index(<<~RUBY)
+        class BasicObject; end
+      RUBY
+
+      entries = @index["BasicObject"]
+      assert_equal(2, entries.length)
+      reopened_entry = entries.last
+      assert_nil(reopened_entry.parent_class)
+      assert_equal(["BasicObject"], @index.linearized_ancestors_of("BasicObject"))
+    end
+
     def test_object_superclass_resolution
-      @index.index_single(IndexablePath.new(nil, "/fake/path/foo.rb"), <<~RUBY)
+      index(<<~RUBY)
         module Foo
           class Object; end
 
@@ -1162,8 +1221,25 @@ module RubyIndexer
       )
     end
 
+    def test_basic_object_superclass_resolution
+      index(<<~RUBY)
+        module Foo
+          class BasicObject; end
+
+          class Bar; end
+          class Baz < BasicObject; end
+        end
+      RUBY
+
+      assert_equal(["Foo::Bar", "Object", "Kernel", "BasicObject"], @index.linearized_ancestors_of("Foo::Bar"))
+      assert_equal(
+        ["Foo::Baz", "Foo::BasicObject", "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)
+      index(<<~RUBY)
         module Foo
           class Object; end
 
@@ -1173,5 +1249,463 @@ module RubyIndexer
 
       assert_equal(["Foo::Bar", "Object", "Kernel", "BasicObject"], @index.linearized_ancestors_of("Foo::Bar"))
     end
+
+    def test_top_level_basic_object_superclass_resolution
+      index(<<~RUBY)
+        module Foo
+          class BasicObject; end
+
+          class Bar < ::BasicObject; end
+        end
+      RUBY
+
+      assert_equal(["Foo::Bar", "BasicObject"], @index.linearized_ancestors_of("Foo::Bar"))
+    end
+
+    def test_resolving_method_inside_singleton_context
+      @index.index_single(IndexablePath.new(nil, "/fake/path/foo.rb"), <<~RUBY)
+        module Foo
+          class Bar
+            class << self
+              class Baz
+                class << self
+                  def found_me!; end
+                end
+              end
+            end
+          end
+        end
+      RUBY
+
+      entry = @index.resolve_method("found_me!", "Foo::Bar::<Class:Bar>::Baz::<Class:Baz>")&.first
+      refute_nil(entry)
+
+      assert_equal("found_me!", T.must(entry).name)
+    end
+
+    def test_resolving_constants_in_singleton_contexts
+      @index.index_single(IndexablePath.new(nil, "/fake/path/foo.rb"), <<~RUBY)
+        module Foo
+          class Bar
+            CONST = 3
+
+            class << self
+              CONST = 2
+
+              class Baz
+                CONST = 1
+
+                class << self
+                end
+              end
+            end
+          end
+        end
+      RUBY
+
+      entry = @index.resolve("CONST", ["Foo", "Bar", "<Class:Bar>", "Baz", "<Class:Baz>"])&.first
+      refute_nil(entry)
+      assert_equal(9, T.must(entry).location.start_line)
+    end
+
+    def test_resolving_instance_variables_in_singleton_contexts
+      @index.index_single(IndexablePath.new(nil, "/fake/path/foo.rb"), <<~RUBY)
+        module Foo
+          class Bar
+            @a = 123
+
+            class << self
+              def hello
+                @b = 123
+              end
+
+              @c = 123
+            end
+          end
+        end
+      RUBY
+
+      entry = @index.resolve_instance_variable("@a", "Foo::Bar::<Class:Bar>")&.first
+      refute_nil(entry)
+      assert_equal("@a", T.must(entry).name)
+
+      entry = @index.resolve_instance_variable("@b", "Foo::Bar::<Class:Bar>")&.first
+      refute_nil(entry)
+      assert_equal("@b", T.must(entry).name)
+
+      entry = @index.resolve_instance_variable("@c", "Foo::Bar::<Class:Bar>::<Class:<Class:Bar>>")&.first
+      refute_nil(entry)
+      assert_equal("@c", T.must(entry).name)
+    end
+
+    def test_instance_variable_completion_in_singleton_contexts
+      @index.index_single(IndexablePath.new(nil, "/fake/path/foo.rb"), <<~RUBY)
+        module Foo
+          class Bar
+            @a = 123
+
+            class << self
+              def hello
+                @b = 123
+              end
+
+              @c = 123
+            end
+          end
+        end
+      RUBY
+
+      entries = @index.instance_variable_completion_candidates("@", "Foo::Bar::<Class:Bar>").map(&:name)
+      assert_includes(entries, "@a")
+      assert_includes(entries, "@b")
+    end
+
+    def test_singletons_are_excluded_from_prefix_search
+      index(<<~RUBY)
+        class Zwq
+          class << self
+          end
+        end
+      RUBY
+
+      assert_empty(@index.prefix_search("Zwq::<C"))
+    end
+
+    def test_singletons_are_excluded_from_fuzzy_search
+      index(<<~RUBY)
+        class Zwq
+          class << self
+          end
+        end
+      RUBY
+
+      results = @index.fuzzy_search("Zwq")
+      assert_equal(1, results.length)
+      assert_equal("Zwq", results.first.name)
+    end
+
+    def test_resolving_method_aliases
+      index(<<~RUBY)
+        class Foo
+          def bar(a, b, c)
+          end
+
+          alias double_alias bar
+        end
+
+        class Bar < Foo
+          def hello(b); end
+
+          alias baz bar
+          alias_method :qux, :hello
+          alias double double_alias
+        end
+      RUBY
+
+      # baz
+      methods = @index.resolve_method("baz", "Bar")
+      refute_nil(methods)
+
+      entry = T.must(methods.first)
+      assert_kind_of(Entry::MethodAlias, entry)
+      assert_equal("bar", entry.target.name)
+      assert_equal("Foo", T.must(entry.target.owner).name)
+
+      # qux
+      methods = @index.resolve_method("qux", "Bar")
+      refute_nil(methods)
+
+      entry = T.must(methods.first)
+      assert_kind_of(Entry::MethodAlias, entry)
+      assert_equal("hello", entry.target.name)
+      assert_equal("Bar", T.must(entry.target.owner).name)
+
+      # double
+      methods = @index.resolve_method("double", "Bar")
+      refute_nil(methods)
+
+      entry = T.must(methods.first)
+      assert_kind_of(Entry::MethodAlias, entry)
+
+      target = entry.target
+      assert_equal("double_alias", target.name)
+      assert_kind_of(Entry::MethodAlias, target)
+      assert_equal("Foo", T.must(target.owner).name)
+
+      final_target = target.target
+      assert_equal("bar", final_target.name)
+      assert_kind_of(Entry::Method, final_target)
+      assert_equal("Foo", T.must(final_target.owner).name)
+    end
+
+    def test_resolving_circular_method_aliases
+      index(<<~RUBY)
+        class Foo
+          alias bar bar
+        end
+      RUBY
+
+      # It's not possible to resolve an alias that points to itself
+      methods = @index.resolve_method("bar", "Foo")
+      assert_nil(methods)
+
+      entry = T.must(@index["bar"].first)
+      assert_kind_of(Entry::UnresolvedMethodAlias, entry)
+    end
+
+    def test_unresolable_method_aliases
+      index(<<~RUBY)
+        class Foo
+          alias bar baz
+        end
+      RUBY
+
+      # `baz` does not exist, so resolving `bar` is not possible
+      methods = @index.resolve_method("bar", "Foo")
+      assert_nil(methods)
+
+      entry = T.must(@index["bar"].first)
+      assert_kind_of(Entry::UnresolvedMethodAlias, entry)
+    end
+
+    def test_only_aliases_for_the_right_owner_are_resolved
+      index(<<~RUBY)
+        class Foo
+          attr_reader :name
+          alias_method :decorated_name, :name
+        end
+
+        class Bar
+          alias_method :decorated_name, :to_s
+        end
+      RUBY
+
+      methods = @index.resolve_method("decorated_name", "Foo")
+      refute_nil(methods)
+
+      entry = T.must(methods.first)
+      assert_kind_of(Entry::MethodAlias, entry)
+
+      target = entry.target
+      assert_equal("name", target.name)
+      assert_kind_of(Entry::Accessor, target)
+      assert_equal("Foo", T.must(target.owner).name)
+
+      other_decorated_name = T.must(@index["decorated_name"].find { |e| e.is_a?(Entry::UnresolvedMethodAlias) })
+      assert_kind_of(Entry::UnresolvedMethodAlias, other_decorated_name)
+    end
+
+    def test_completion_does_not_include_unresolved_aliases
+      index(<<~RUBY)
+        class Foo
+          alias_method :bar, :missing
+        end
+      RUBY
+
+      assert_empty(@index.method_completion_candidates("bar", "Foo"))
+    end
+
+    def test_completion_does_not_duplicate_overridden_methods
+      index(<<~RUBY)
+        class Foo
+          def bar; end
+        end
+
+        class Baz < Foo
+          def bar; end
+        end
+      RUBY
+
+      entries = @index.method_completion_candidates("bar", "Baz")
+      assert_equal(["bar"], entries.map(&:name))
+      assert_equal("Baz", T.must(entries.first.owner).name)
+    end
+
+    def test_completion_does_not_duplicate_methods_overridden_by_aliases
+      index(<<~RUBY)
+        class Foo
+          def bar; end
+        end
+
+        class Baz < Foo
+          alias bar to_s
+        end
+      RUBY
+
+      entries = @index.method_completion_candidates("bar", "Baz")
+      assert_equal(["bar"], entries.map(&:name))
+      assert_equal("Baz", T.must(entries.first.owner).name)
+    end
+
+    def test_decorated_parameters
+      index(<<~RUBY)
+        class Foo
+          def bar(a, b = 1, c: 2)
+          end
+        end
+      RUBY
+
+      methods = @index.resolve_method("bar", "Foo")
+      refute_nil(methods)
+
+      entry = T.must(methods.first)
+
+      assert_equal("(a, b = <default>, c: <default>)", entry.decorated_parameters)
+    end
+
+    def test_decorated_parameters_when_method_has_no_parameters
+      index(<<~RUBY)
+        class Foo
+          def bar
+          end
+        end
+      RUBY
+
+      methods = @index.resolve_method("bar", "Foo")
+      refute_nil(methods)
+
+      entry = T.must(methods.first)
+
+      assert_equal("()", entry.decorated_parameters)
+    end
+
+    def test_linearizing_singleton_ancestors_of_singleton_when_class_has_parent
+      @index.index_single(IndexablePath.new(nil, "/fake/path/foo.rb"), <<~RUBY)
+        class Foo; end
+
+        class Bar < Foo
+        end
+
+        class Baz < Bar
+          class << self
+            class << self
+            end
+          end
+        end
+      RUBY
+
+      assert_equal(
+        [
+          "Baz::<Class:Baz>::<Class:<Class:Baz>>",
+          "Bar::<Class:Bar>::<Class:<Class:Bar>>",
+          "Foo::<Class:Foo>::<Class:<Class:Foo>>",
+          "Object::<Class:Object>::<Class:<Class:Object>>",
+          "BasicObject::<Class:BasicObject>::<Class:<Class:BasicObject>>",
+          "Class::<Class:Class>",
+          "Module::<Class:Module>",
+          "Object::<Class:Object>",
+          "BasicObject::<Class:BasicObject>",
+          "Class",
+          "Module",
+          "Object",
+          "Kernel",
+          "BasicObject",
+        ],
+        @index.linearized_ancestors_of("Baz::<Class:Baz>::<Class:<Class:Baz>>"),
+      )
+    end
+
+    def test_linearizing_singleton_object
+      assert_equal(
+        [
+          "Object::<Class:Object>",
+          "BasicObject::<Class:BasicObject>",
+          "Class",
+          "Module",
+          "Object",
+          "Kernel",
+          "BasicObject",
+        ],
+        @index.linearized_ancestors_of("Object::<Class:Object>"),
+      )
+    end
+
+    def test_linearizing_singleton_ancestors
+      @index.index_single(IndexablePath.new(nil, "/fake/path/foo.rb"), <<~RUBY)
+        module First
+        end
+
+        module Second
+          include First
+        end
+
+        module Foo
+          class Bar
+            class << self
+              class Baz
+                extend Second
+
+                class << self
+                  include First
+                end
+              end
+            end
+          end
+        end
+      RUBY
+
+      assert_equal(
+        [
+          "Foo::Bar::<Class:Bar>::Baz::<Class:Baz>",
+          "Second",
+          "First",
+          "Object::<Class:Object>",
+          "BasicObject::<Class:BasicObject>",
+          "Class",
+          "Module",
+          "Object",
+          "Kernel",
+          "BasicObject",
+        ],
+        @index.linearized_ancestors_of("Foo::Bar::<Class:Bar>::Baz::<Class:Baz>"),
+      )
+    end
+
+    def test_linearizing_singleton_ancestors_when_class_has_parent
+      @index.index_single(IndexablePath.new(nil, "/fake/path/foo.rb"), <<~RUBY)
+        class Foo; end
+
+        class Bar < Foo
+        end
+
+        class Baz < Bar
+          class << self
+          end
+        end
+      RUBY
+
+      assert_equal(
+        [
+          "Baz::<Class:Baz>",
+          "Bar::<Class:Bar>",
+          "Foo::<Class:Foo>",
+          "Object::<Class:Object>",
+          "BasicObject::<Class:BasicObject>",
+          "Class",
+          "Module",
+          "Object",
+          "Kernel",
+          "BasicObject",
+        ],
+        @index.linearized_ancestors_of("Baz::<Class:Baz>"),
+      )
+    end
+
+    def test_linearizing_a_module_singleton_class
+      @index.index_single(IndexablePath.new(nil, "/fake/path/foo.rb"), <<~RUBY)
+        module A; end
+      RUBY
+
+      assert_equal(
+        [
+          "A::<Class:A>",
+          "Module",
+          "Object",
+          "Kernel",
+          "BasicObject",
+        ],
+        @index.linearized_ancestors_of("A::<Class:A>"),
+      )
+    end
   end
 end