ruby-lsp 0.21.0 → 0.22.1

data/lib/ruby_indexer/test/enhancements_test.rb

@@ -5,24 +5,28 @@ require_relative "test_case"
 
 module RubyIndexer
   class EnhancementTest < TestCase
+    def teardown
+      super
+      Enhancement.clear
+    end
+
     def test_enhancing_indexing_included_hook
-      enhancement_class = Class.new(Enhancement) do
-        def on_call_node_enter(owner, node, file_path, code_units_cache)
+      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)
@@ -31,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
@@ -48,7 +47,6 @@ module RubyIndexer
         end
       end
 
-      @index.register_enhancement(enhancement_class.new(@index))
       index(<<~RUBY)
         module ActiveSupport
           module Concern
@@ -96,9 +94,9 @@ module RubyIndexer
     end
 
     def test_enhancing_indexing_configuration_dsl
-      enhancement_class = Class.new(Enhancement) do
-        def on_call_node_enter(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
@@ -109,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))
       index(<<~RUBY)
         module ActiveSupport
           module Concern
@@ -157,8 +147,8 @@ module RubyIndexer
     end
 
     def test_error_handling_in_on_call_node_enter_enhancement
-      enhancement_class = Class.new(Enhancement) do
-        def on_call_node_enter(owner, node, file_path, code_units_cache)
+      Class.new(Enhancement) do
+        def on_call_node_enter(node) # rubocop:disable RubyLsp/UseRegisterWithHandlerMethod
           raise "Error"
         end
 
@@ -169,8 +159,6 @@ module RubyIndexer
         end
       end
 
-      @index.register_enhancement(enhancement_class.new(@index))
-
       _stdout, stderr = capture_io do
         index(<<~RUBY)
           module ActiveSupport
@@ -192,8 +180,8 @@ module RubyIndexer
     end
 
     def test_error_handling_in_on_call_node_leave_enhancement
-      enhancement_class = Class.new(Enhancement) do
-        def on_call_node_leave(owner, node, file_path, code_units_cache)
+      Class.new(Enhancement) do
+        def on_call_node_leave(node) # rubocop:disable RubyLsp/UseRegisterWithHandlerMethod
           raise "Error"
         end
 
@@ -204,8 +192,6 @@ module RubyIndexer
         end
       end
 
-      @index.register_enhancement(enhancement_class.new(@index))
-
       _stdout, stderr = capture_io do
         index(<<~RUBY)
           module ActiveSupport
@@ -225,5 +211,115 @@ module RubyIndexer
       # 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

@@ -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/method_test.rb

@@ -141,7 +141,7 @@ module RubyIndexer
         # 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_equal(Entry::Visibility::PRIVATE, first_entry.visibility)
+        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)
@@ -149,6 +149,119 @@ module RubyIndexer
       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

data/lib/ruby_lsp/client_capabilities.rb

@@ -10,7 +10,8 @@ module RubyLsp
     sig { returns(T::Boolean) }
     attr_reader :supports_watching_files,
       :supports_request_delegation,
-      :window_show_message_supports_extra_properties
+      :window_show_message_supports_extra_properties,
+      :supports_progress
 
     sig { void }
     def initialize
@@ -28,6 +29,9 @@ module RubyLsp
 
       # Which resource operations the editor supports, like renaming files
       @supported_resource_operations = T.let([], T::Array[String])
+
+      # The editor supports displaying progress requests
+      @supports_progress = T.let(false, T::Boolean)
     end
 
     sig { params(capabilities: T::Hash[Symbol, T.untyped]).void }
@@ -50,6 +54,9 @@ module RubyLsp
         :additionalPropertiesSupport,
       )
       @window_show_message_supports_extra_properties = supports_additional_properties || false
+
+      progress = capabilities.dig(:window, :workDoneProgress)
+      @supports_progress = progress if progress
     end
 
     sig { returns(T::Boolean) }

data/lib/ruby_lsp/global_state.rb

@@ -21,7 +21,7 @@ module RubyLsp
     attr_reader :encoding
 
     sig { returns(T::Boolean) }
-    attr_reader :experimental_features, :top_level_bundle
+    attr_reader :top_level_bundle
 
     sig { returns(TypeInferrer) }
     attr_reader :type_inferrer
@@ -40,7 +40,6 @@ module RubyLsp
       @has_type_checker = T.let(true, T::Boolean)
       @index = T.let(RubyIndexer::Index.new, RubyIndexer::Index)
       @supported_formatters = T.let({}, T::Hash[String, Requests::Support::Formatter])
-      @experimental_features = T.let(false, T::Boolean)
       @type_inferrer = T.let(TypeInferrer.new(@index), TypeInferrer)
       @addon_settings = T.let({}, T::Hash[String, T.untyped])
       @top_level_bundle = T.let(
@@ -53,6 +52,7 @@ module RubyLsp
         T::Boolean,
       )
       @client_capabilities = T.let(ClientCapabilities.new, ClientCapabilities)
+      @enabled_feature_flags = T.let({}, T::Hash[Symbol, T::Boolean])
     end
 
     sig { params(addon_name: String).returns(T.nilable(T::Hash[Symbol, T.untyped])) }
@@ -130,7 +130,6 @@ module RubyLsp
       end
       @index.configuration.encoding = @encoding
 
-      @experimental_features = options.dig(:initializationOptions, :experimentalFeaturesEnabled) || false
       @client_capabilities.apply_client_capabilities(options[:capabilities]) if options[:capabilities]
 
       addon_settings = options.dig(:initializationOptions, :addonSettings)
@@ -139,9 +138,17 @@ module RubyLsp
         @addon_settings.merge!(addon_settings)
       end
 
+      enabled_flags = options.dig(:initializationOptions, :enabledFeatureFlags)
+      @enabled_feature_flags = enabled_flags if enabled_flags
+
       notifications
     end
 
+    sig { params(flag: Symbol).returns(T.nilable(T::Boolean)) }
+    def enabled_feature?(flag)
+      @enabled_feature_flags[:all] || @enabled_feature_flags[flag]
+    end
+
     sig { returns(String) }
     def workspace_path
       T.must(@workspace_uri.to_standardized_path)
@@ -159,6 +166,11 @@ module RubyLsp
       end
     end
 
+    sig { returns(T::Boolean) }
+    def supports_watching_files
+      @client_capabilities.supports_watching_files
+    end
+
     private
 
     sig { params(direct_dependencies: T::Array[String], all_dependencies: T::Array[String]).returns(String) }

data/lib/ruby_lsp/internal.rb

@@ -21,6 +21,7 @@ require "prism"
 require "prism/visitor"
 require "language_server-protocol"
 require "rbs"
+require "fileutils"
 
 require "ruby-lsp"
 require "ruby_lsp/base_server"

data/lib/ruby_lsp/listeners/document_highlight.rb

@@ -92,14 +92,15 @@ module RubyLsp
           target: T.nilable(Prism::Node),
           parent: T.nilable(Prism::Node),
           dispatcher: Prism::Dispatcher,
+          position: T::Hash[Symbol, T.untyped],
         ).void
       end
-      def initialize(response_builder, target, parent, dispatcher)
+      def initialize(response_builder, target, parent, dispatcher, position)
         @response_builder = response_builder
 
         return unless target && parent
 
-        highlight_target =
+        highlight_target, highlight_target_value =
           case target
           when Prism::GlobalVariableReadNode, Prism::GlobalVariableAndWriteNode, Prism::GlobalVariableOperatorWriteNode,
             Prism::GlobalVariableOrWriteNode, Prism::GlobalVariableTargetNode, Prism::GlobalVariableWriteNode,
@@ -116,13 +117,17 @@ module RubyLsp
             Prism::CallNode, Prism::BlockParameterNode, Prism::RequiredKeywordParameterNode,
             Prism::RequiredKeywordParameterNode, Prism::KeywordRestParameterNode, Prism::OptionalParameterNode,
             Prism::RequiredParameterNode, Prism::RestParameterNode
+            [target, node_value(target)]
+          when Prism::ModuleNode, Prism::ClassNode, Prism::SingletonClassNode, Prism::DefNode, Prism::CaseNode,
+            Prism::WhileNode, Prism::UntilNode, Prism::ForNode, Prism::IfNode, Prism::UnlessNode
             target
           end
 
         @target = T.let(highlight_target, T.nilable(Prism::Node))
-        @target_value = T.let(node_value(highlight_target), T.nilable(String))
+        @target_value = T.let(highlight_target_value, T.nilable(String))
+        @target_position = position
 
-        if @target && @target_value
+        if @target
           dispatcher.register(
             self,
             :on_call_node_enter,
@@ -172,6 +177,13 @@ module RubyLsp
             :on_global_variable_or_write_node_enter,
             :on_global_variable_and_write_node_enter,
             :on_global_variable_operator_write_node_enter,
+            :on_singleton_class_node_enter,
+            :on_case_node_enter,
+            :on_while_node_enter,
+            :on_until_node_enter,
+            :on_for_node_enter,
+            :on_if_node_enter,
+            :on_unless_node_enter,
           )
         end
       end
@@ -189,6 +201,8 @@ module RubyLsp
 
       sig { params(node: Prism::DefNode).void }
       def on_def_node_enter(node)
+        add_matching_end_highlights(node.def_keyword_loc, node.end_keyword_loc) if @target.is_a?(Prism::DefNode)
+
         return unless matches?(node, [Prism::CallNode, Prism::DefNode])
 
         add_highlight(Constant::DocumentHighlightKind::WRITE, node.name_loc)
@@ -252,6 +266,8 @@ module RubyLsp
 
       sig { params(node: Prism::ClassNode).void }
       def on_class_node_enter(node)
+        add_matching_end_highlights(node.class_keyword_loc, node.end_keyword_loc) if @target.is_a?(Prism::ClassNode)
+
         return unless matches?(node, CONSTANT_NODES + CONSTANT_PATH_NODES + [Prism::ClassNode])
 
         add_highlight(Constant::DocumentHighlightKind::WRITE, node.constant_path.location)
@@ -259,6 +275,8 @@ module RubyLsp
 
       sig { params(node: Prism::ModuleNode).void }
       def on_module_node_enter(node)
+        add_matching_end_highlights(node.module_keyword_loc, node.end_keyword_loc) if @target.is_a?(Prism::ModuleNode)
+
         return unless matches?(node, CONSTANT_NODES + CONSTANT_PATH_NODES + [Prism::ModuleNode])
 
         add_highlight(Constant::DocumentHighlightKind::WRITE, node.constant_path.location)
@@ -511,6 +529,55 @@ module RubyLsp
         add_highlight(Constant::DocumentHighlightKind::WRITE, node.name_loc)
       end
 
+      sig { params(node: Prism::SingletonClassNode).void }
+      def on_singleton_class_node_enter(node)
+        return unless @target.is_a?(Prism::SingletonClassNode)
+
+        add_matching_end_highlights(node.class_keyword_loc, node.end_keyword_loc)
+      end
+
+      sig { params(node: Prism::CaseNode).void }
+      def on_case_node_enter(node)
+        return unless @target.is_a?(Prism::CaseNode)
+
+        add_matching_end_highlights(node.case_keyword_loc, node.end_keyword_loc)
+      end
+
+      sig { params(node: Prism::WhileNode).void }
+      def on_while_node_enter(node)
+        return unless @target.is_a?(Prism::WhileNode)
+
+        add_matching_end_highlights(node.keyword_loc, node.closing_loc)
+      end
+
+      sig { params(node: Prism::UntilNode).void }
+      def on_until_node_enter(node)
+        return unless @target.is_a?(Prism::UntilNode)
+
+        add_matching_end_highlights(node.keyword_loc, node.closing_loc)
+      end
+
+      sig { params(node: Prism::ForNode).void }
+      def on_for_node_enter(node)
+        return unless @target.is_a?(Prism::ForNode)
+
+        add_matching_end_highlights(node.for_keyword_loc, node.end_keyword_loc)
+      end
+
+      sig { params(node: Prism::IfNode).void }
+      def on_if_node_enter(node)
+        return unless @target.is_a?(Prism::IfNode)
+
+        add_matching_end_highlights(node.if_keyword_loc, node.end_keyword_loc)
+      end
+
+      sig { params(node: Prism::UnlessNode).void }
+      def on_unless_node_enter(node)
+        return unless @target.is_a?(Prism::UnlessNode)
+
+        add_matching_end_highlights(node.keyword_loc, node.end_keyword_loc)
+      end
+
       private
 
       sig { params(node: Prism::Node, classes: T::Array[T.class_of(Prism::Node)]).returns(T.nilable(T::Boolean)) }
@@ -550,6 +617,26 @@ module RubyLsp
           node.constant_path.slice
         end
       end
+
+      sig { params(keyword_loc: T.nilable(Prism::Location), end_loc: T.nilable(Prism::Location)).void }
+      def add_matching_end_highlights(keyword_loc, end_loc)
+        return unless keyword_loc && end_loc && end_loc.length.positive?
+        return unless covers_target_position?(keyword_loc) || covers_target_position?(end_loc)
+
+        add_highlight(Constant::DocumentHighlightKind::TEXT, keyword_loc)
+        add_highlight(Constant::DocumentHighlightKind::TEXT, end_loc)
+      end
+
+      sig { params(location: Prism::Location).returns(T::Boolean) }
+      def covers_target_position?(location)
+        start_line = location.start_line - 1
+        end_line = location.end_line - 1
+        start_covered = start_line < @target_position[:line] ||
+          (start_line == @target_position[:line] && location.start_column <= @target_position[:character])
+        end_covered = end_line > @target_position[:line] ||
+          (end_line == @target_position[:line] && location.end_column >= @target_position[:character])
+        start_covered && end_covered
+      end
     end
   end
 end