ruby-lsp 0.16.6 → 0.17.0

data/lib/ruby_indexer/test/constant_test.rb

@@ -12,10 +12,13 @@ module RubyIndexer
         class ::Bar
           FOO = 2
         end
+
+        BAR = 3 if condition
       RUBY
 
       assert_entry("FOO", Entry::Constant, "/fake/path/foo.rb:0-0:0-7")
       assert_entry("Bar::FOO", Entry::Constant, "/fake/path/foo.rb:3-2:3-9")
+      assert_entry("BAR", Entry::Constant, "/fake/path/foo.rb:6-0:6-7")
     end
 
     def test_constant_or_writes
@@ -119,13 +122,13 @@ module RubyIndexer
       RUBY
 
       b_const = @index["A::B"].first
-      assert_equal(:private, b_const.visibility)
+      assert_equal(Entry::Visibility::PRIVATE, b_const.visibility)
 
       c_const = @index["A::C"].first
-      assert_equal(:private, c_const.visibility)
+      assert_equal(Entry::Visibility::PRIVATE, c_const.visibility)
 
       d_const = @index["A::D"].first
-      assert_equal(:public, d_const.visibility)
+      assert_equal(Entry::Visibility::PUBLIC, d_const.visibility)
     end
 
     def test_marking_constants_as_private_reopening_namespaces
@@ -152,13 +155,13 @@ module RubyIndexer
       RUBY
 
       a_const = @index["A::B::CONST_A"].first
-      assert_equal(:private, a_const.visibility)
+      assert_equal(Entry::Visibility::PRIVATE, a_const.visibility)
 
       b_const = @index["A::B::CONST_B"].first
-      assert_equal(:private, b_const.visibility)
+      assert_equal(Entry::Visibility::PRIVATE, b_const.visibility)
 
       c_const = @index["A::B::CONST_C"].first
-      assert_equal(:private, c_const.visibility)
+      assert_equal(Entry::Visibility::PRIVATE, c_const.visibility)
     end
 
     def test_marking_constants_as_private_with_receiver
@@ -176,10 +179,10 @@ module RubyIndexer
       RUBY
 
       a_const = @index["A::B::CONST_A"].first
-      assert_equal(:private, a_const.visibility)
+      assert_equal(Entry::Visibility::PRIVATE, a_const.visibility)
 
       b_const = @index["A::B::CONST_B"].first
-      assert_equal(:private, b_const.visibility)
+      assert_equal(Entry::Visibility::PRIVATE, b_const.visibility)
     end
 
     def test_indexing_constant_aliases

data/lib/ruby_indexer/test/index_test.rb

@@ -299,6 +299,10 @@ module RubyIndexer
     end
 
     def test_indexing_prism_fixtures_succeeds
+      unless Dir.exist?("test/fixtures/prism/test/prism/fixtures")
+        raise "Prism fixtures not found. Run `git submodule update --init` to fetch them."
+      end
+
       fixtures = Dir.glob("test/fixtures/prism/test/prism/fixtures/**/*.txt")
 
       fixtures.each do |fixture|
@@ -313,5 +317,529 @@ module RubyIndexer
       @index.index_single(IndexablePath.new(nil, "/fake/path/foo.rb"))
       assert_empty(@index.instance_variable_get(:@entries))
     end
+
+    def test_linearized_ancestors_basic_ordering
+      index(<<~RUBY)
+        module A; end
+        module B; end
+
+        class Foo
+          prepend A
+          prepend B
+        end
+
+        class Bar
+          include A
+          include B
+        end
+      RUBY
+
+      assert_equal(
+        [
+          "B",
+          "A",
+          "Foo",
+          # "Object",
+          # "Kernel",
+          # "BasicObject",
+        ],
+        @index.linearized_ancestors_of("Foo"),
+      )
+
+      assert_equal(
+        [
+          "Bar",
+          "B",
+          "A",
+          # "Object",
+          # "Kernel",
+          # "BasicObject",
+        ],
+        @index.linearized_ancestors_of("Bar"),
+      )
+    end
+
+    def test_linearized_ancestors
+      index(<<~RUBY)
+        module A; end
+        module B; end
+        module C; end
+
+        module D
+          include A
+        end
+
+        module E
+          prepend B
+        end
+
+        module F
+          include C
+          include A
+        end
+
+        class Bar
+          prepend F
+        end
+
+        class Foo < Bar
+          include E
+          prepend D
+        end
+      RUBY
+
+      # Object, Kernel and BasicObject are intentionally commented out for now until we develop a strategy for indexing
+      # declarations made in C code
+      assert_equal(
+        [
+          "D",
+          "A",
+          "Foo",
+          "B",
+          "E",
+          "F",
+          "A",
+          "C",
+          "Bar",
+          # "Object",
+          # "Kernel",
+          # "BasicObject",
+        ],
+        @index.linearized_ancestors_of("Foo"),
+      )
+    end
+
+    def test_linearized_ancestors_duplicates
+      index(<<~RUBY)
+        module A; end
+        module B
+          include A
+        end
+
+        class Foo
+          include B
+          include A
+        end
+
+        class Bar
+          prepend B
+          prepend A
+        end
+      RUBY
+
+      assert_equal(
+        [
+          "Foo",
+          "B",
+          "A",
+          # "Object",
+          # "Kernel",
+          # "BasicObject",
+        ],
+        @index.linearized_ancestors_of("Foo"),
+      )
+
+      assert_equal(
+        [
+          "B",
+          "A",
+          "Bar",
+          # "Object",
+          # "Kernel",
+          # "BasicObject",
+        ],
+        @index.linearized_ancestors_of("Bar"),
+      )
+    end
+
+    def test_linearizing_ancestors_is_cached
+      index(<<~RUBY)
+        module C; end
+        module A; end
+        module B
+          include A
+        end
+
+        class Foo
+          include B
+          include A
+        end
+      RUBY
+
+      @index.linearized_ancestors_of("Foo")
+      ancestors = @index.instance_variable_get(:@ancestors)
+      assert(ancestors.key?("Foo"))
+      assert(ancestors.key?("A"))
+      assert(ancestors.key?("B"))
+      refute(ancestors.key?("C"))
+    end
+
+    def test_duplicate_prepend_include
+      index(<<~RUBY)
+        module A; end
+
+        class Foo
+          prepend A
+          include A
+        end
+
+        class Bar
+          include A
+          prepend A
+        end
+      RUBY
+
+      assert_equal(
+        [
+          "A",
+          "Foo",
+          # "Object",
+          # "Kernel",
+          # "BasicObject",
+        ],
+        @index.linearized_ancestors_of("Foo"),
+      )
+
+      assert_equal(
+        [
+          "A",
+          "Bar",
+          "A",
+          # "Object",
+          # "Kernel",
+          # "BasicObject",
+        ],
+        @index.linearized_ancestors_of("Bar"),
+      )
+    end
+
+    def test_linearizing_ancestors_handles_circular_parent_class
+      index(<<~RUBY)
+        class Foo < Foo
+        end
+      RUBY
+
+      assert_equal(
+        [
+          "Foo",
+          # "Object",
+          # "Kernel",
+          # "BasicObject",
+        ],
+        @index.linearized_ancestors_of("Foo"),
+      )
+    end
+
+    def test_ancestors_linearization_complex_prepend_duplication
+      index(<<~RUBY)
+        module A; end
+        module B
+          prepend A
+        end
+        module C
+          prepend B
+        end
+
+        class Foo
+          prepend A
+          prepend C
+        end
+      RUBY
+
+      assert_equal(
+        [
+          "A",
+          "B",
+          "C",
+          "Foo",
+          # "Object",
+          # "Kernel",
+          # "BasicObject",
+        ],
+        @index.linearized_ancestors_of("Foo"),
+      )
+    end
+
+    def test_ancestors_linearization_complex_include_duplication
+      index(<<~RUBY)
+        module A; end
+        module B
+          include A
+        end
+        module C
+          include B
+        end
+
+        class Foo
+          include A
+          include C
+        end
+      RUBY
+
+      assert_equal(
+        [
+          "Foo",
+          "C",
+          "B",
+          "A",
+          # "Object",
+          # "Kernel",
+          # "BasicObject",
+        ],
+        @index.linearized_ancestors_of("Foo"),
+      )
+    end
+
+    def test_linearizing_ancestors_that_need_to_be_resolved
+      index(<<~RUBY)
+        module Foo
+          module Baz
+          end
+          module Qux
+          end
+
+          class Something; end
+
+          class Bar < Something
+            include Baz
+            prepend Qux
+          end
+        end
+      RUBY
+
+      assert_equal(
+        [
+          "Foo::Qux",
+          "Foo::Bar",
+          "Foo::Baz",
+          "Foo::Something",
+          # "Object",
+          # "Kernel",
+          # "BasicObject",
+        ],
+        @index.linearized_ancestors_of("Foo::Bar"),
+      )
+    end
+
+    def test_linearizing_ancestors_for_non_existing_namespaces
+      index(<<~RUBY)
+        module Kernel
+          def Array(a); end
+        end
+      RUBY
+
+      assert_raises(Index::NonExistingNamespaceError) do
+        @index.linearized_ancestors_of("Foo")
+      end
+
+      assert_raises(Index::NonExistingNamespaceError) do
+        @index.linearized_ancestors_of("Array")
+      end
+    end
+
+    def test_linearizing_circular_ancestors
+      index(<<~RUBY)
+        module M1
+          include M2
+        end
+
+        module M2
+          include M1
+        end
+
+        module A1
+          include A2
+        end
+
+        module A2
+          include A3
+        end
+
+        module A3
+          include A1
+        end
+
+        class Foo < Foo
+          include Foo
+        end
+
+        module Bar
+          include Bar
+        end
+      RUBY
+
+      assert_equal(["M2", "M1"], @index.linearized_ancestors_of("M2"))
+      assert_equal(["A3", "A1", "A2"], @index.linearized_ancestors_of("A3"))
+      assert_equal(["Foo"], @index.linearized_ancestors_of("Foo"))
+      assert_equal(["Bar"], @index.linearized_ancestors_of("Bar"))
+    end
+
+    def test_linearizing_circular_aliased_dependency
+      index(<<~RUBY)
+        module A
+        end
+
+        ALIAS = A
+
+        module A
+          include ALIAS
+        end
+      RUBY
+
+      assert_equal(["A", "ALIAS"], @index.linearized_ancestors_of("A"))
+    end
+
+    def test_resolving_an_inherited_method
+      index(<<~RUBY)
+        module Foo
+          def baz; end
+        end
+
+        class Bar
+          def qux; end
+        end
+
+        class Wow < Bar
+          include Foo
+        end
+      RUBY
+
+      entry = T.must(@index.resolve_method("baz", "Wow")&.first)
+      assert_equal("baz", entry.name)
+      assert_equal("Foo", T.must(entry.owner).name)
+
+      entry = T.must(@index.resolve_method("qux", "Wow")&.first)
+      assert_equal("qux", entry.name)
+      assert_equal("Bar", T.must(entry.owner).name)
+    end
+
+    def test_resolving_an_inherited_method_lands_on_first_match
+      index(<<~RUBY)
+        module Foo
+          def qux; end
+        end
+
+        class Bar
+          def qux; end
+        end
+
+        class Wow < Bar
+          prepend Foo
+
+          def qux; end
+        end
+      RUBY
+
+      entries = T.must(@index.resolve_method("qux", "Wow"))
+      assert_equal(1, entries.length)
+
+      entry = T.must(entries.first)
+      assert_equal("qux", entry.name)
+      assert_equal("Foo", T.must(entry.owner).name)
+    end
+
+    def test_handle_change_clears_ancestor_cache_if_tree_changed
+      Dir.mktmpdir do |dir|
+        Dir.chdir(dir) do
+          # Write the original file
+          File.write(File.join(dir, "foo.rb"), <<~RUBY)
+            module Foo
+            end
+
+            class Bar
+              include Foo
+            end
+          RUBY
+
+          indexable_path = IndexablePath.new(nil, File.join(dir, "foo.rb"))
+          @index.index_single(indexable_path)
+
+          assert_equal(["Bar", "Foo"], @index.linearized_ancestors_of("Bar"))
+
+          # Remove include to invalidate the ancestor tree
+          File.write(File.join(dir, "foo.rb"), <<~RUBY)
+            module Foo
+            end
+
+            class Bar
+            end
+          RUBY
+
+          @index.handle_change(indexable_path)
+          assert_empty(@index.instance_variable_get(:@ancestors))
+          assert_equal(["Bar"], @index.linearized_ancestors_of("Bar"))
+        end
+      end
+    end
+
+    def test_handle_change_does_not_clear_ancestor_cache_if_tree_not_changed
+      Dir.mktmpdir do |dir|
+        Dir.chdir(dir) do
+          # Write the original file
+          File.write(File.join(dir, "foo.rb"), <<~RUBY)
+            module Foo
+            end
+
+            class Bar
+              include Foo
+            end
+          RUBY
+
+          indexable_path = IndexablePath.new(nil, File.join(dir, "foo.rb"))
+          @index.index_single(indexable_path)
+
+          assert_equal(["Bar", "Foo"], @index.linearized_ancestors_of("Bar"))
+
+          # Remove include to invalidate the ancestor tree
+          File.write(File.join(dir, "foo.rb"), <<~RUBY)
+            module Foo
+            end
+
+            class Bar
+              include Foo
+
+              def baz; end
+            end
+          RUBY
+
+          @index.handle_change(indexable_path)
+          refute_empty(@index.instance_variable_get(:@ancestors))
+          assert_equal(["Bar", "Foo"], @index.linearized_ancestors_of("Bar"))
+        end
+      end
+    end
+
+    def test_handle_change_clears_ancestor_cache_if_parent_class_changed
+      Dir.mktmpdir do |dir|
+        Dir.chdir(dir) do
+          # Write the original file
+          File.write(File.join(dir, "foo.rb"), <<~RUBY)
+            class Foo
+            end
+
+            class Bar < Foo
+            end
+          RUBY
+
+          indexable_path = IndexablePath.new(nil, File.join(dir, "foo.rb"))
+          @index.index_single(indexable_path)
+
+          assert_equal(["Bar", "Foo"], @index.linearized_ancestors_of("Bar"))
+
+          # Remove include to invalidate the ancestor tree
+          File.write(File.join(dir, "foo.rb"), <<~RUBY)
+            class Foo
+            end
+
+            class Bar
+            end
+          RUBY
+
+          @index.handle_change(indexable_path)
+          assert_empty(@index.instance_variable_get(:@ancestors))
+          assert_equal(["Bar"], @index.linearized_ancestors_of("Bar"))
+        end
+      end
+    end
   end
 end

data/lib/ruby_indexer/test/instance_variables_test.rb

@@ -0,0 +1,131 @@
+# typed: true
+# frozen_string_literal: true
+
+require_relative "test_case"
+
+module RubyIndexer
+  class InstanceVariableTest < TestCase
+    def test_instance_variable_write
+      index(<<~RUBY)
+        module Foo
+          class Bar
+            def initialize
+              # Hello
+              @a = 1
+            end
+          end
+        end
+      RUBY
+
+      assert_entry("@a", Entry::InstanceVariable, "/fake/path/foo.rb:4-6:4-8")
+
+      entry = T.must(@index["@a"]&.first)
+      assert_equal("Foo::Bar", T.must(entry.owner).name)
+    end
+
+    def test_instance_variable_and_write
+      index(<<~RUBY)
+        module Foo
+          class Bar
+            def initialize
+              # Hello
+              @a &&= value
+            end
+          end
+        end
+      RUBY
+
+      assert_entry("@a", Entry::InstanceVariable, "/fake/path/foo.rb:4-6:4-8")
+
+      entry = T.must(@index["@a"]&.first)
+      assert_equal("Foo::Bar", T.must(entry.owner).name)
+    end
+
+    def test_instance_variable_operator_write
+      index(<<~RUBY)
+        module Foo
+          class Bar
+            def initialize
+              # Hello
+              @a += value
+            end
+          end
+        end
+      RUBY
+
+      assert_entry("@a", Entry::InstanceVariable, "/fake/path/foo.rb:4-6:4-8")
+
+      entry = T.must(@index["@a"]&.first)
+      assert_equal("Foo::Bar", T.must(entry.owner).name)
+    end
+
+    def test_instance_variable_or_write
+      index(<<~RUBY)
+        module Foo
+          class Bar
+            def initialize
+              # Hello
+              @a ||= value
+            end
+          end
+        end
+      RUBY
+
+      assert_entry("@a", Entry::InstanceVariable, "/fake/path/foo.rb:4-6:4-8")
+
+      entry = T.must(@index["@a"]&.first)
+      assert_equal("Foo::Bar", T.must(entry.owner).name)
+    end
+
+    def test_instance_variable_target
+      index(<<~RUBY)
+        module Foo
+          class Bar
+            def initialize
+              # Hello
+              @a, @b = [1, 2]
+            end
+          end
+        end
+      RUBY
+
+      assert_entry("@a", Entry::InstanceVariable, "/fake/path/foo.rb:4-6:4-8")
+      assert_entry("@b", Entry::InstanceVariable, "/fake/path/foo.rb:4-10:4-12")
+
+      entry = T.must(@index["@a"]&.first)
+      assert_equal("Foo::Bar", T.must(entry.owner).name)
+
+      entry = T.must(@index["@b"]&.first)
+      assert_equal("Foo::Bar", T.must(entry.owner).name)
+    end
+
+    def test_empty_name_instance_variables
+      index(<<~RUBY)
+        module Foo
+          class Bar
+            def initialize
+              @ = 123
+            end
+          end
+        end
+      RUBY
+
+      refute_entry("@")
+    end
+
+    def test_class_instance_variables
+      index(<<~RUBY)
+        module Foo
+          class Bar
+            @a = 123
+          end
+        end
+      RUBY
+
+      assert_entry("@a", Entry::InstanceVariable, "/fake/path/foo.rb:2-4:2-6")
+
+      entry = T.must(@index["@a"]&.first)
+      assert_equal("Foo::Bar", T.must(entry.owner).name)
+    end
+  end
+end