ruby-lsp 0.20.1 → 0.22.1

data/lib/ruby_indexer/lib/ruby_indexer/entry.rb

@@ -646,7 +646,7 @@ module RubyIndexer
         (positionals.empty? && forwarding_arguments.any?) ||
           (
             # Check if positional arguments match. This includes required, optional, rest arguments. We also need to
-            # verify if there's a trailing forwading argument, like `def foo(a, ...); end`
+            # verify if there's a trailing forwarding argument, like `def foo(a, ...); end`
             positional_arguments_match?(positionals, forwarding_arguments, keyword_args, min_pos, max_pos) &&
             # If the positional arguments match, we move on to checking keyword, optional keyword and keyword rest
             # arguments. If there's a forward argument, then it will always match. If the method accepts a keyword rest

data/lib/ruby_indexer/lib/ruby_indexer/index.rb

@@ -7,6 +7,7 @@ module RubyIndexer
 
     class UnresolvableAliasError < StandardError; end
     class NonExistingNamespaceError < StandardError; end
+    class IndexNotEmptyError < StandardError; end
 
     # The minimum Jaro-Winkler similarity score for an entry to be considered a match for a given fuzzy search query
     ENTRY_SIMILARITY_THRESHOLD = 0.7
@@ -39,9 +40,6 @@ module RubyIndexer
       # Holds the linearized ancestors list for every namespace
       @ancestors = T.let({}, T::Hash[String, T::Array[String]])
 
-      # List of classes that are enhancing the index
-      @enhancements = T.let([], T::Array[Enhancement])
-
       # Map of module name to included hooks that have to be executed when we include the given module
       @included_hooks = T.let(
         {},
@@ -51,12 +49,6 @@ module RubyIndexer
       @configuration = T.let(RubyIndexer::Configuration.new, Configuration)
     end
 
-    # Register an enhancement to the index. Enhancements must conform to the `Enhancement` interface
-    sig { params(enhancement: Enhancement).void }
-    def register_enhancement(enhancement)
-      @enhancements << enhancement
-    end
-
     # Register an included `hook` that will be executed when `module_name` is included into any namespace
     sig { params(module_name: String, hook: T.proc.params(index: Index, base: Entry::Namespace).void).void }
     def register_included_hook(module_name, &hook)
@@ -360,6 +352,15 @@ module RubyIndexer
       ).void
     end
     def index_all(indexable_paths: @configuration.indexables, &block)
+      # When troubleshooting an indexing issue, e.g. through irb, it's not obvious that `index_all` will augment the
+      # existing index values, meaning it may contain 'stale' entries. This check ensures that the user is aware of this
+      # behavior and can take appropriate action.
+      # binding.break
+      if @entries.any?
+        raise IndexNotEmptyError,
+          "The index is not empty. To prevent invalid entries, `index_all` can only be called once."
+      end
+
       RBSIndexer.new(self).index_ruby_core
       # Calculate how many paths are worth 1% of progress
       progress_step = (indexable_paths.length / 100.0).ceil
@@ -386,7 +387,6 @@ module RubyIndexer
         result,
         indexable_path.full_path,
         collect_comments: collect_comments,
-        enhancements: @enhancements,
       )
       dispatcher.dispatch(result.value)
 
@@ -784,7 +784,7 @@ module RubyIndexer
       singleton_levels
     )
       # Find the first class entry that has a parent class. Notice that if the developer makes a mistake and inherits
-      # from two diffent classes in different files, we simply ignore it
+      # from two different classes in different files, we simply ignore it
       superclass = T.cast(
         if singleton_levels > 0
           self[attached_class_name]&.find { |n| n.is_a?(Entry::Class) && n.parent_class }
@@ -974,10 +974,10 @@ module RubyIndexer
       []
     end
 
-    # Removes redudancy from a constant reference's full name. For example, if we find a reference to `A::B::Foo` inside
-    # of the ["A", "B"] nesting, then we should not concatenate the nesting with the name or else we'll end up with
-    # `A::B::A::B::Foo`. This method will remove any redundant parts from the final name based on the reference and the
-    # nesting
+    # Removes redundancy from a constant reference's full name. For example, if we find a reference to `A::B::Foo`
+    # inside of the ["A", "B"] nesting, then we should not concatenate the nesting with the name or else we'll end up
+    # with `A::B::A::B::Foo`. This method will remove any redundant parts from the final name based on the reference and
+    # the nesting
     sig { params(name: String, nesting: T::Array[String]).returns(String) }
     def build_non_redundant_full_name(name, nesting)
       # If there's no nesting, then we can just return the name as is

data/lib/ruby_indexer/test/classes_and_modules_test.rb

@@ -72,7 +72,7 @@ module RubyIndexer
       assert_entry("self::Bar", Entry::Class, "/fake/path/foo.rb:0-0:1-3")
     end
 
-    def test_dynamically_namespaced_class_doesnt_affect_other_classes
+    def test_dynamically_namespaced_class_does_not_affect_other_classes
       index(<<~RUBY)
         class Foo
           class self::Bar
@@ -143,7 +143,7 @@ module RubyIndexer
       assert_entry("self::Bar", Entry::Module, "/fake/path/foo.rb:0-0:1-3")
     end
 
-    def test_dynamically_namespaced_module_doesnt_affect_other_modules
+    def test_dynamically_namespaced_module_does_not_affect_other_modules
       index(<<~RUBY)
         module Foo
           class self::Bar
@@ -302,10 +302,10 @@ module RubyIndexer
       RUBY
 
       b_const = @index["A::B"].first
-      assert_equal(Entry::Visibility::PRIVATE, b_const.visibility)
+      assert_predicate(b_const, :private?)
 
       c_const = @index["A::C"].first
-      assert_equal(Entry::Visibility::PRIVATE, c_const.visibility)
+      assert_predicate(c_const, :private?)
 
       d_const = @index["A::D"].first
       assert_equal(Entry::Visibility::PUBLIC, d_const.visibility)

data/lib/ruby_indexer/test/configuration_test.rb

@@ -160,5 +160,15 @@ module RubyIndexer
         )
       end
     end
+
+    def test_includes_top_level_files
+      Dir.mktmpdir do |dir|
+        FileUtils.touch(File.join(dir, "find_me.rb"))
+        @config.workspace_path = dir
+
+        indexables = @config.indexables
+        assert(indexables.find { |i| File.basename(i.full_path) == "find_me.rb" })
+      end
+    end
   end
 end

data/lib/ruby_indexer/test/constant_test.rb

@@ -130,13 +130,13 @@ module RubyIndexer
       RUBY
 
       b_const = @index["A::B"].first
-      assert_equal(Entry::Visibility::PRIVATE, b_const.visibility)
+      assert_predicate(b_const, :private?)
 
       c_const = @index["A::C"].first
-      assert_equal(Entry::Visibility::PRIVATE, c_const.visibility)
+      assert_predicate(c_const, :private?)
 
       d_const = @index["A::D"].first
-      assert_equal(Entry::Visibility::PUBLIC, d_const.visibility)
+      assert_predicate(d_const, :public?)
     end
 
     def test_marking_constants_as_private_reopening_namespaces
@@ -163,13 +163,13 @@ module RubyIndexer
       RUBY
 
       a_const = @index["A::B::CONST_A"].first
-      assert_equal(Entry::Visibility::PRIVATE, a_const.visibility)
+      assert_predicate(a_const, :private?)
 
       b_const = @index["A::B::CONST_B"].first
-      assert_equal(Entry::Visibility::PRIVATE, b_const.visibility)
+      assert_predicate(b_const, :private?)
 
       c_const = @index["A::B::CONST_C"].first
-      assert_equal(Entry::Visibility::PRIVATE, c_const.visibility)
+      assert_predicate(c_const, :private?)
     end
 
     def test_marking_constants_as_private_with_receiver
@@ -187,10 +187,10 @@ module RubyIndexer
       RUBY
 
       a_const = @index["A::B::CONST_A"].first
-      assert_equal(Entry::Visibility::PRIVATE, a_const.visibility)
+      assert_predicate(a_const, :private?)
 
       b_const = @index["A::B::CONST_B"].first
-      assert_equal(Entry::Visibility::PRIVATE, b_const.visibility)
+      assert_predicate(b_const, :private?)
     end
 
     def test_indexing_constant_aliases

data/lib/ruby_indexer/test/enhancements_test.rb

@@ -5,26 +5,28 @@ require_relative "test_case"
 
 module RubyIndexer
   class EnhancementTest < TestCase
-    def test_enhancing_indexing_included_hook
-      enhancement_class = Class.new do
-        include Enhancement
+    def teardown
+      super
+      Enhancement.clear
+    end
 
-        def on_call_node(index, owner, node, file_path, code_units_cache)
+    def test_enhancing_indexing_included_hook
+      Class.new(Enhancement) do
+        def on_call_node_enter(call_node) # rubocop:disable RubyLsp/UseRegisterWithHandlerMethod
+          owner = @listener.current_owner
           return unless owner
-          return unless node.name == :extend
+          return unless call_node.name == :extend
 
-          arguments = node.arguments&.arguments
+          arguments = call_node.arguments&.arguments
           return unless arguments
 
-          location = Location.from_prism_location(node.location, code_units_cache)
-
           arguments.each do |node|
             next unless node.is_a?(Prism::ConstantReadNode) || node.is_a?(Prism::ConstantPathNode)
 
             module_name = node.full_name
             next unless module_name == "ActiveSupport::Concern"
 
-            index.register_included_hook(owner.name) do |index, base|
+            @listener.register_included_hook do |index, base|
               class_methods_name = "#{owner.name}::ClassMethods"
 
               if index.indexed?(class_methods_name)
@@ -33,16 +35,11 @@ module RubyIndexer
               end
             end
 
-            index.add(Entry::Method.new(
+            @listener.add_method(
               "new_method",
-              file_path,
-              location,
-              location,
-              nil,
+              call_node.location,
               [Entry::Signature.new([Entry::RequiredParameter.new(name: :a)])],
-              Entry::Visibility::PUBLIC,
-              owner,
-            ))
+            )
           rescue Prism::ConstantPathNode::DynamicPartsInConstantPathError,
                  Prism::ConstantPathNode::MissingNodesInConstantPathError
             # Do nothing
@@ -50,7 +47,6 @@ module RubyIndexer
         end
       end
 
-      @index.register_enhancement(enhancement_class.new)
       index(<<~RUBY)
         module ActiveSupport
           module Concern
@@ -98,11 +94,9 @@ module RubyIndexer
     end
 
     def test_enhancing_indexing_configuration_dsl
-      enhancement_class = Class.new do
-        include Enhancement
-
-        def on_call_node(index, owner, node, file_path, code_units_cache)
-          return unless owner
+      Class.new(Enhancement) do
+        def on_call_node_enter(node) # rubocop:disable RubyLsp/UseRegisterWithHandlerMethod
+          return unless @listener.current_owner
 
           name = node.name
           return unless name == :has_many
@@ -113,22 +107,14 @@ module RubyIndexer
           association_name = arguments.first
           return unless association_name.is_a?(Prism::SymbolNode)
 
-          location = Location.from_prism_location(association_name.location, code_units_cache)
-
-          index.add(Entry::Method.new(
+          @listener.add_method(
             T.must(association_name.value),
-            file_path,
-            location,
-            location,
-            nil,
+            association_name.location,
             [],
-            Entry::Visibility::PUBLIC,
-            owner,
-          ))
+          )
         end
       end
 
-      @index.register_enhancement(enhancement_class.new)
       index(<<~RUBY)
         module ActiveSupport
           module Concern
@@ -160,11 +146,9 @@ module RubyIndexer
       assert_entry("posts", Entry::Method, "/fake/path/foo.rb:23-11:23-17")
     end
 
-    def test_error_handling_in_enhancement
-      enhancement_class = Class.new do
-        include Enhancement
-
-        def on_call_node(index, owner, node, file_path, code_units_cache)
+    def test_error_handling_in_on_call_node_enter_enhancement
+      Class.new(Enhancement) do
+        def on_call_node_enter(node) # rubocop:disable RubyLsp/UseRegisterWithHandlerMethod
           raise "Error"
         end
 
@@ -175,7 +159,38 @@ module RubyIndexer
         end
       end
 
-      @index.register_enhancement(enhancement_class.new)
+      _stdout, stderr = capture_io do
+        index(<<~RUBY)
+          module ActiveSupport
+            module Concern
+              def self.extended(base)
+                base.class_eval("def new_method(a); end")
+              end
+            end
+          end
+        RUBY
+      end
+
+      assert_match(
+        %r{Indexing error in /fake/path/foo\.rb with 'TestEnhancement' on call node enter enhancement},
+        stderr,
+      )
+      # The module should still be indexed
+      assert_entry("ActiveSupport::Concern", Entry::Module, "/fake/path/foo.rb:1-2:5-5")
+    end
+
+    def test_error_handling_in_on_call_node_leave_enhancement
+      Class.new(Enhancement) do
+        def on_call_node_leave(node) # rubocop:disable RubyLsp/UseRegisterWithHandlerMethod
+          raise "Error"
+        end
+
+        class << self
+          def name
+            "TestEnhancement"
+          end
+        end
+      end
 
       _stdout, stderr = capture_io do
         index(<<~RUBY)
@@ -189,9 +204,122 @@ module RubyIndexer
         RUBY
       end
 
-      assert_match(%r{Indexing error in /fake/path/foo\.rb with 'TestEnhancement' enhancement}, stderr)
+      assert_match(
+        %r{Indexing error in /fake/path/foo\.rb with 'TestEnhancement' on call node leave enhancement},
+        stderr,
+      )
       # The module should still be indexed
       assert_entry("ActiveSupport::Concern", Entry::Module, "/fake/path/foo.rb:1-2:5-5")
     end
+
+    def test_advancing_namespace_stack_from_enhancement
+      Class.new(Enhancement) do
+        def on_call_node_enter(call_node) # rubocop:disable RubyLsp/UseRegisterWithHandlerMethod
+          owner = @listener.current_owner
+          return unless owner
+
+          case call_node.name
+          when :class_methods
+            @listener.add_module("ClassMethods", call_node.location, call_node.location)
+          when :extend
+            arguments = call_node.arguments&.arguments
+            return unless arguments
+
+            arguments.each do |node|
+              next unless node.is_a?(Prism::ConstantReadNode) || node.is_a?(Prism::ConstantPathNode)
+
+              module_name = node.full_name
+              next unless module_name == "ActiveSupport::Concern"
+
+              @listener.register_included_hook do |index, base|
+                class_methods_name = "#{owner.name}::ClassMethods"
+
+                if index.indexed?(class_methods_name)
+                  singleton = index.existing_or_new_singleton_class(base.name)
+                  singleton.mixin_operations << Entry::Include.new(class_methods_name)
+                end
+              end
+            end
+          end
+        end
+
+        def on_call_node_leave(call_node) # rubocop:disable RubyLsp/UseRegisterWithHandlerMethod
+          return unless call_node.name == :class_methods
+
+          @listener.pop_namespace_stack
+        end
+      end
+
+      index(<<~RUBY)
+        module ActiveSupport
+          module Concern
+          end
+        end
+
+        module MyConcern
+          extend ActiveSupport::Concern
+
+          class_methods do
+            def foo; end
+          end
+        end
+
+        class User
+          include MyConcern
+        end
+      RUBY
+
+      assert_equal(
+        [
+          "User::<Class:User>",
+          "MyConcern::ClassMethods",
+          "Object::<Class:Object>",
+          "BasicObject::<Class:BasicObject>",
+          "Class",
+          "Module",
+          "Object",
+          "Kernel",
+          "BasicObject",
+        ],
+        @index.linearized_ancestors_of("User::<Class:User>"),
+      )
+
+      refute_nil(@index.resolve_method("foo", "User::<Class:User>"))
+    end
+
+    def test_creating_anonymous_classes_from_enhancement
+      Class.new(Enhancement) do
+        def on_call_node_enter(call_node) # rubocop:disable RubyLsp/UseRegisterWithHandlerMethod
+          case call_node.name
+          when :context
+            arguments = call_node.arguments&.arguments
+            first_argument = arguments&.first
+            return unless first_argument.is_a?(Prism::StringNode)
+
+            @listener.add_class(
+              "<RSpec:#{first_argument.content}>",
+              call_node.location,
+              first_argument.location,
+            )
+          when :subject
+            @listener.add_method("subject", call_node.location, [])
+          end
+        end
+
+        def on_call_node_leave(call_node) # rubocop:disable RubyLsp/UseRegisterWithHandlerMethod
+          return unless call_node.name == :context
+
+          @listener.pop_namespace_stack
+        end
+      end
+
+      index(<<~RUBY)
+        context "does something" do
+          subject { call_whatever }
+        end
+      RUBY
+
+      refute_nil(@index.resolve_method("subject", "<RSpec:does something>"))
+    end
   end
 end

data/lib/ruby_indexer/test/index_test.rb

@@ -904,7 +904,7 @@ module RubyIndexer
       assert_equal(14, entry.location.start_line)
     end
 
-    def test_resolving_inherited_alised_namespace
+    def test_resolving_inherited_aliased_namespace
       index(<<~RUBY)
         module Bar
           TARGET = 123
@@ -1490,7 +1490,7 @@ module RubyIndexer
       assert_kind_of(Entry::UnresolvedMethodAlias, entry)
     end
 
-    def test_unresolable_method_aliases
+    def test_unresolvable_method_aliases
       index(<<~RUBY)
         class Foo
           alias bar baz
@@ -1672,6 +1672,38 @@ module RubyIndexer
       )
     end
 
+    def test_extend_self
+      @index.index_single(IndexablePath.new(nil, "/fake/path/foo.rb"), <<~RUBY)
+        module Foo
+          def bar
+          end
+
+          extend self
+
+          def baz
+          end
+        end
+      RUBY
+
+      ["bar", "baz"].product(["Foo", "Foo::<Class:Foo>"]).each do |method, receiver|
+        entry = @index.resolve_method(method, receiver)&.first
+        refute_nil(entry)
+        assert_equal(method, T.must(entry).name)
+      end
+
+      assert_equal(
+        [
+          "Foo::<Class:Foo>",
+          "Foo",
+          "Module",
+          "Object",
+          "Kernel",
+          "BasicObject",
+        ],
+        @index.linearized_ancestors_of("Foo::<Class:Foo>"),
+      )
+    end
+
     def test_linearizing_singleton_ancestors
       @index.index_single(IndexablePath.new(nil, "/fake/path/foo.rb"), <<~RUBY)
         module First
@@ -2023,5 +2055,12 @@ module RubyIndexer
         ),
       )
     end
+
+    def test_prevents_multiple_calls_to_index_all
+      # For this test class, `index_all` is already called once in `setup`.
+      assert_raises(Index::IndexNotEmptyError) do
+        @index.index_all
+      end
+    end
   end
 end

data/lib/ruby_indexer/test/instance_variables_test.rb

@@ -209,7 +209,7 @@ module RubyIndexer
         end
       RUBY
 
-      # If the surrounding method is beind defined on any dynamic value that isn't `self`, then we attribute the
+      # If the surrounding method is being defined on any dynamic value that isn't `self`, then we attribute the
       # instance variable to the wrong owner since there's no way to understand that statically
       entry = T.must(@index["@a"]&.first)
       owner = T.must(entry.owner)

data/lib/ruby_indexer/test/method_test.rb

@@ -123,6 +123,145 @@ module RubyIndexer
       assert_entry("baz", Entry::Method, "/fake/path/foo.rb:9-2:9-14", visibility: Entry::Visibility::PRIVATE)
     end
 
+    def test_visibility_tracking_with_module_function
+      index(<<~RUBY)
+        module Test
+          def foo; end
+          def bar; end
+          module_function :foo, "bar"
+        end
+      RUBY
+
+      ["foo", "bar"].each do |keyword|
+        entries = T.must(@index[keyword])
+        # should receive two entries because module_function creates a singleton method
+        # for the Test module and a private method for classes include the Test module
+        assert_equal(entries.size, 2)
+        first_entry, second_entry = *entries
+        # The first entry points to the location of the module_function call
+        assert_equal("Test", first_entry.owner.name)
+        assert_instance_of(Entry::Module, first_entry.owner)
+        assert_predicate(first_entry, :private?)
+        # The second entry points to the public singleton method
+        assert_equal("Test::<Class:Test>", second_entry.owner.name)
+        assert_instance_of(Entry::SingletonClass, second_entry.owner)
+        assert_equal(Entry::Visibility::PUBLIC, second_entry.visibility)
+      end
+    end
+
+    def test_private_class_method_visibility_tracking_string_symbol_arguments
+      index(<<~RUBY)
+        class Test
+          def self.foo
+          end
+
+          def self.bar
+          end
+
+          private_class_method("foo", :bar)
+
+          def self.baz
+          end
+        end
+      RUBY
+
+      ["foo", "bar"].each do |keyword|
+        entries = T.must(@index[keyword])
+        assert_equal(1, entries.size)
+        entry = entries.first
+        assert_predicate(entry, :private?)
+      end
+
+      entries = T.must(@index["baz"])
+      assert_equal(1, entries.size)
+      entry = entries.first
+      assert_predicate(entry, :public?)
+    end
+
+    def test_private_class_method_visibility_tracking_array_argument
+      index(<<~RUBY)
+        class Test
+          def self.foo
+          end
+
+          def self.bar
+          end
+
+          private_class_method(["foo", :bar])
+
+          def self.baz
+          end
+        end
+      RUBY
+
+      ["foo", "bar"].each do |keyword|
+        entries = T.must(@index[keyword])
+        assert_equal(1, entries.size)
+        entry = entries.first
+        assert_predicate(entry, :private?)
+      end
+
+      entries = T.must(@index["baz"])
+      assert_equal(1, entries.size)
+      entry = entries.first
+      assert_predicate(entry, :public?)
+    end
+
+    def test_private_class_method_visibility_tracking_method_argument
+      index(<<~RUBY)
+        class Test
+          private_class_method def self.foo
+          end
+
+          def self.bar
+          end
+        end
+      RUBY
+
+      entries = T.must(@index["foo"])
+      assert_equal(1, entries.size)
+      entry = entries.first
+      assert_predicate(entry, :private?)
+
+      entries = T.must(@index["bar"])
+      assert_equal(1, entries.size)
+      entry = entries.first
+      assert_predicate(entry, :public?)
+    end
+
+    def test_comments_documentation
+      index(<<~RUBY)
+        # Documentation for Foo
+
+        class Foo
+          # ####################
+          # Documentation for bar
+          # ####################
+          #
+          def bar
+          end
+
+          # test
+
+          # Documentation for baz
+          def baz; end
+          def ban; end
+        end
+      RUBY
+
+      foo_comment = @index["Foo"].first.comments
+      assert_equal("Documentation for Foo", foo_comment)
+
+      bar_comment = @index["bar"].first.comments
+      assert_equal("####################\nDocumentation for bar\n####################\n", bar_comment)
+
+      baz_comment = @index["baz"].first.comments
+      assert_equal("Documentation for baz", baz_comment)
+
+      ban_comment = @index["ban"].first.comments
+      assert_empty(ban_comment)
+    end
+
     def test_method_with_parameters
       index(<<~RUBY)
         class Foo