ruby-lsp 0.17.4 → 0.17.6

data/lib/ruby_indexer/test/index_test.rb

@@ -313,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
 
@@ -1007,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
@@ -1321,11 +1358,6 @@ module RubyIndexer
       entries = @index.instance_variable_completion_candidates("@", "Foo::Bar::<Class:Bar>").map(&:name)
       assert_includes(entries, "@a")
       assert_includes(entries, "@b")
-
-      assert_includes(
-        @index.instance_variable_completion_candidates("@", "Foo::Bar::<Class:Bar>::<Class:<Class:Bar>>").map(&:name),
-        "@c",
-      )
     end
 
     def test_singletons_are_excluded_from_prefix_search
@@ -1472,5 +1504,214 @@ module RubyIndexer
 
       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
+
+    def test_linearizing_a_singleton_class_with_no_attached
+      assert_raises(Index::NonExistingNamespaceError) do
+        @index.linearized_ancestors_of("A::<Class:A>")
+      end
+    end
   end
 end

data/lib/ruby_indexer/test/method_test.rb

@@ -123,8 +123,9 @@ module RubyIndexer
 
       assert_entry("bar", Entry::Method, "/fake/path/foo.rb:1-2:2-5")
       entry = T.must(@index["bar"].first)
-      assert_equal(1, entry.parameters.length)
-      parameter = entry.parameters.first
+      parameters = entry.signatures.first.parameters
+      assert_equal(1, parameters.length)
+      parameter = parameters.first
       assert_equal(:a, parameter.name)
       assert_instance_of(Entry::RequiredParameter, parameter)
     end
@@ -139,8 +140,9 @@ module RubyIndexer
 
       assert_entry("bar", Entry::Method, "/fake/path/foo.rb:1-2:2-5")
       entry = T.must(@index["bar"].first)
-      assert_equal(1, entry.parameters.length)
-      parameter = entry.parameters.first
+      parameters = entry.signatures.first.parameters
+      assert_equal(1, parameters.length)
+      parameter = parameters.first
       assert_equal(:"(a, (b, ))", parameter.name)
       assert_instance_of(Entry::RequiredParameter, parameter)
     end
@@ -155,8 +157,9 @@ module RubyIndexer
 
       assert_entry("bar", Entry::Method, "/fake/path/foo.rb:1-2:2-5")
       entry = T.must(@index["bar"].first)
-      assert_equal(1, entry.parameters.length)
-      parameter = entry.parameters.first
+      parameters = entry.signatures.first.parameters
+      assert_equal(1, parameters.length)
+      parameter = parameters.first
       assert_equal(:a, parameter.name)
       assert_instance_of(Entry::OptionalParameter, parameter)
     end
@@ -171,8 +174,9 @@ module RubyIndexer
 
       assert_entry("bar", Entry::Method, "/fake/path/foo.rb:1-2:2-5")
       entry = T.must(@index["bar"].first)
-      assert_equal(2, entry.parameters.length)
-      a, b = entry.parameters
+      parameters = entry.signatures.first.parameters
+      assert_equal(2, parameters.length)
+      a, b = parameters
 
       assert_equal(:a, a.name)
       assert_instance_of(Entry::KeywordParameter, a)
@@ -191,8 +195,9 @@ module RubyIndexer
 
       assert_entry("bar", Entry::Method, "/fake/path/foo.rb:1-2:2-5")
       entry = T.must(@index["bar"].first)
-      assert_equal(2, entry.parameters.length)
-      a, b = entry.parameters
+      parameters = entry.signatures.first.parameters
+      assert_equal(2, parameters.length)
+      a, b = parameters
 
       assert_equal(:a, a.name)
       assert_instance_of(Entry::RestParameter, a)
@@ -216,8 +221,9 @@ module RubyIndexer
 
       assert_entry("bar", Entry::Method, "/fake/path/foo.rb:1-2:2-5")
       entry = T.must(@index["bar"].first)
-      assert_equal(2, entry.parameters.length)
-      a, b = entry.parameters
+      parameters = entry.signatures.first.parameters
+      assert_equal(2, parameters.length)
+      a, b = parameters
 
       assert_equal(:a, a.name)
       assert_instance_of(Entry::RestParameter, a)
@@ -226,8 +232,9 @@ module RubyIndexer
       assert_instance_of(Entry::RequiredParameter, b)
 
       entry = T.must(@index["baz"].first)
-      assert_equal(2, entry.parameters.length)
-      a, b = entry.parameters
+      parameters = entry.signatures.first.parameters
+      assert_equal(2, parameters.length)
+      a, b = parameters
 
       assert_equal(:a, a.name)
       assert_instance_of(Entry::KeywordRestParameter, a)
@@ -236,8 +243,9 @@ module RubyIndexer
       assert_instance_of(Entry::RequiredParameter, b)
 
       entry = T.must(@index["qux"].first)
-      assert_equal(2, entry.parameters.length)
-      _a, second = entry.parameters
+      parameters = entry.signatures.first.parameters
+      assert_equal(2, parameters.length)
+      _a, second = parameters
 
       assert_equal(:"(b, c)", second.name)
       assert_instance_of(Entry::RequiredParameter, second)
@@ -253,8 +261,9 @@ module RubyIndexer
 
       assert_entry("bar", Entry::Method, "/fake/path/foo.rb:1-2:2-5")
       entry = T.must(@index["bar"].first)
-      assert_equal(1, entry.parameters.length)
-      param = entry.parameters.first
+      parameters = entry.signatures.first.parameters
+      assert_equal(1, parameters.length)
+      param = parameters.first
 
       assert_equal(:"(a, *b)", param.name)
       assert_instance_of(Entry::RequiredParameter, param)
@@ -272,14 +281,16 @@ module RubyIndexer
       RUBY
 
       entry = T.must(@index["bar"].first)
-      param = entry.parameters.first
+      parameters = entry.signatures.first.parameters
+      param = parameters.first
       assert_equal(:block, param.name)
       assert_instance_of(Entry::BlockParameter, param)
 
       entry = T.must(@index["baz"].first)
-      assert_equal(1, entry.parameters.length)
+      parameters = entry.signatures.first.parameters
+      assert_equal(1, parameters.length)
 
-      param = entry.parameters.first
+      param = parameters.first
       assert_equal(Entry::BlockParameter::DEFAULT_NAME, param.name)
       assert_instance_of(Entry::BlockParameter, param)
     end
@@ -294,8 +305,9 @@ module RubyIndexer
 
       assert_entry("bar", Entry::Method, "/fake/path/foo.rb:1-2:2-5")
       entry = T.must(@index["bar"].first)
-      assert_equal(2, entry.parameters.length)
-      first, second = entry.parameters
+      parameters = entry.signatures.first.parameters
+      assert_equal(2, parameters.length)
+      first, second = parameters
 
       assert_equal(Entry::RestParameter::DEFAULT_NAME, first.name)
       assert_instance_of(Entry::RestParameter, first)
@@ -314,7 +326,8 @@ module RubyIndexer
 
       assert_entry("bar", Entry::Method, "/fake/path/foo.rb:1-2:2-5")
       entry = T.must(@index["bar"].first)
-      assert_empty(entry.parameters)
+      parameters = entry.signatures.first.parameters
+      assert_empty(parameters)
     end
 
     def test_keeps_track_of_method_owner
@@ -401,7 +414,7 @@ module RubyIndexer
       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)
+      assert_equal(4, @index.length - @default_indexed_entries.length)
     end
 
     def test_singleton_methods
@@ -428,5 +441,25 @@ module RubyIndexer
       # the exact same
       assert_same(bar_owner, baz_owner)
     end
+
+    def test_name_location_points_to_method_identifier_location
+      index(<<~RUBY)
+        class Foo
+          def bar
+            a = 123
+            a + 456
+          end
+        end
+      RUBY
+
+      entry = T.must(@index["bar"].first)
+      refute_equal(entry.location, entry.name_location)
+
+      name_location = entry.name_location
+      assert_equal(2, name_location.start_line)
+      assert_equal(2, name_location.end_line)
+      assert_equal(6, name_location.start_column)
+      assert_equal(9, name_location.end_column)
+    end
   end
 end