ruby-lsp 0.21.3 → 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/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(
@@ -131,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)
@@ -148,7 +146,7 @@ module RubyLsp
 
     sig { params(flag: Symbol).returns(T.nilable(T::Boolean)) }
     def enabled_feature?(flag)
-      @enabled_feature_flags[flag]
+      @enabled_feature_flags[:all] || @enabled_feature_flags[flag]
     end
 
     sig { 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_symbol.rb

@@ -41,6 +41,9 @@ module RubyLsp
           :on_module_node_enter,
           :on_module_node_leave,
           :on_instance_variable_write_node_enter,
+          :on_instance_variable_operator_write_node_enter,
+          :on_instance_variable_or_write_node_enter,
+          :on_instance_variable_and_write_node_enter,
           :on_class_variable_write_node_enter,
           :on_singleton_class_node_enter,
           :on_singleton_class_node_leave,
@@ -249,21 +252,51 @@ module RubyLsp
         @response_builder.pop
       end
 
+      sig { params(node: Prism::ClassVariableWriteNode).void }
+      def on_class_variable_write_node_enter(node)
+        create_document_symbol(
+          name: node.name.to_s,
+          kind: Constant::SymbolKind::VARIABLE,
+          range_location: node.name_loc,
+          selection_range_location: node.name_loc,
+        )
+      end
+
       sig { params(node: Prism::InstanceVariableWriteNode).void }
       def on_instance_variable_write_node_enter(node)
         create_document_symbol(
           name: node.name.to_s,
-          kind: Constant::SymbolKind::VARIABLE,
+          kind: Constant::SymbolKind::FIELD,
           range_location: node.name_loc,
           selection_range_location: node.name_loc,
         )
       end
 
-      sig { params(node: Prism::ClassVariableWriteNode).void }
-      def on_class_variable_write_node_enter(node)
+      sig { params(node: Prism::InstanceVariableOperatorWriteNode).void }
+      def on_instance_variable_operator_write_node_enter(node)
         create_document_symbol(
           name: node.name.to_s,
-          kind: Constant::SymbolKind::VARIABLE,
+          kind: Constant::SymbolKind::FIELD,
+          range_location: node.name_loc,
+          selection_range_location: node.name_loc,
+        )
+      end
+
+      sig { params(node: Prism::InstanceVariableOrWriteNode).void }
+      def on_instance_variable_or_write_node_enter(node)
+        create_document_symbol(
+          name: node.name.to_s,
+          kind: Constant::SymbolKind::FIELD,
+          range_location: node.name_loc,
+          selection_range_location: node.name_loc,
+        )
+      end
+
+      sig { params(node: Prism::InstanceVariableAndWriteNode).void }
+      def on_instance_variable_and_write_node_enter(node)
+        create_document_symbol(
+          name: node.name.to_s,
+          kind: Constant::SymbolKind::FIELD,
           range_location: node.name_loc,
           selection_range_location: node.name_loc,
         )

data/lib/ruby_lsp/requests/definition.rb

@@ -118,6 +118,8 @@ module RubyLsp
           Prism::InstanceVariableWriteNode
 
           !covers_position?(target.name_loc, position)
+        when Prism::CallNode
+          !covers_position?(target.message_loc, position)
         else
           false
         end

data/lib/ruby_lsp/requests/hover.rb

@@ -103,6 +103,8 @@ module RubyLsp
           Prism::GlobalVariableOrWriteNode,
           Prism::GlobalVariableWriteNode
           !covers_position?(target.name_loc, position)
+        when Prism::CallNode
+          !covers_position?(target.message_loc, position)
         else
           false
         end

data/lib/ruby_lsp/requests/support/rubocop_runner.rb

@@ -15,6 +15,7 @@ rescue LoadError
   return
 end
 
+# Remember to update the version in the documentation (usage/dependency-compatibility section) if you change this
 # Ensure that RuboCop is at least version 1.4.0
 begin
   gem("rubocop", ">= 1.4.0")

data/lib/ruby_lsp/server.rb

@@ -216,6 +216,13 @@ module RubyLsp
         Hash.new(true)
       end
 
+      bundle_env_path = File.join(".ruby-lsp", "bundle_env")
+      bundle_env = if File.exist?(bundle_env_path)
+        env = File.readlines(bundle_env_path).to_h { |line| T.cast(line.chomp.split("=", 2), [String, String]) }
+        FileUtils.rm(bundle_env_path)
+        env
+      end
+
       document_symbol_provider = Requests::DocumentSymbol.provider if enabled_features["documentSymbols"]
       document_link_provider = Requests::DocumentLink.provider if enabled_features["documentLink"]
       code_lens_provider = Requests::CodeLens.provider if enabled_features["codeLens"]
@@ -269,6 +276,7 @@ module RubyLsp
         },
         formatter: @global_state.formatter,
         degraded_mode: !!(@install_error || @setup_error),
+        bundle_env: bundle_env,
       }
 
       send_message(Result.new(id: message[:id], response: response))
@@ -604,6 +612,11 @@ module RubyLsp
       # don't want to format it
       path = uri.to_standardized_path
       unless path.nil? || path.start_with?(@global_state.workspace_path)
+        send_log_message(<<~MESSAGE)
+          Ignoring formatting request for file outside of the workspace.
+          Workspace path was set by editor as #{@global_state.workspace_path}.
+          File path requested for formatting was #{path}
+        MESSAGE
         send_empty_response(message[:id])
         return
       end