ruby-lsp 0.13.0 → 0.13.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d6bace664e1540c1333df9dabfb2e7bdd8bda0f910033b47b188e4a82ddacb15
-  data.tar.gz: be9e5da0492b26b5cb6e07074d01d7874104b70286c1578342b9639158fed147
+  metadata.gz: 2329129b74c75a0bb4113d1f1489463f666b74ef495d0ac65bad675fbd83d1d3
+  data.tar.gz: 2f31f495b9ca0b1a9f909758dabce816411d0b64a006577c93c7a80a253791e5
 SHA512:
-  metadata.gz: 7d8e61433686271a68dafe8db79765ed509a115ab6f06060d7669d279f48218fe2eada2c12e3b45f155d27a41774771681cdab92700d27f426e75ed89287ca03
-  data.tar.gz: 611c050b751050934d0fd93e9e52089fe63fc4d947be75a440dfa0465933814d2682268a10135d036c2cee83fa739156d2b11e42e679ecbed7de62acfee9d621
+  metadata.gz: 9c3ab34cb3e7877105ca21df3f521589d9838bd15e77a3d17cc4df91ca1f93221ef845e514a902a03a63a1f82ad6b5cf90fa4f9a93037fbfb57af5f7a48b0ebe
+  data.tar.gz: d4867c86eb238abf039f40592d7ff48acd85749fcf9349ab72fdea218ff5201156fc0d511987ed768b1fb2dcc9fd55a76bfac611f3fc565b7b2ba8c8d1054a72

data/VERSION

@@ -1 +1 @@
-0.13.0
+0.13.2

data/lib/ruby_indexer/lib/ruby_indexer/configuration.rb

@@ -193,7 +193,7 @@ module RubyIndexer
       # When working on a gem, we need to make sure that its gemspec dependencies can't be excluded. This is necessary
       # because Bundler doesn't assign groups to gemspec dependencies
       this_gem = Bundler.definition.dependencies.find do |d|
-        d.to_spec.full_gem_path == Dir.pwd
+        d.to_spec&.full_gem_path == Dir.pwd
       rescue Gem::MissingSpecError
         false
       end

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

@@ -81,9 +81,13 @@ module RubyIndexer
 
       abstract!
 
+      # Name includes just the name of the parameter, excluding symbols like splats
       sig { returns(Symbol) }
       attr_reader :name
 
+      # Decorated name is the parameter name including the splat or block prefix, e.g.: `*foo`, `**foo` or `&block`
+      alias_method :decorated_name, :name
+
       sig { params(name: Symbol).void }
       def initialize(name:)
         @name = name
@@ -100,10 +104,48 @@ module RubyIndexer
 
     # An required keyword method parameter, e.g. `def foo(a:)`
     class KeywordParameter < Parameter
+      sig { override.returns(Symbol) }
+      def decorated_name
+        :"#{@name}:"
+      end
     end
 
     # An optional keyword method parameter, e.g. `def foo(a: 123)`
     class OptionalKeywordParameter < Parameter
+      sig { override.returns(Symbol) }
+      def decorated_name
+        :"#{@name}:"
+      end
+    end
+
+    # A rest method parameter, e.g. `def foo(*a)`
+    class RestParameter < Parameter
+      DEFAULT_NAME = T.let(:"<anonymous splat>", Symbol)
+
+      sig { override.returns(Symbol) }
+      def decorated_name
+        :"*#{@name}"
+      end
+    end
+
+    # A keyword rest method parameter, e.g. `def foo(**a)`
+    class KeywordRestParameter < Parameter
+      DEFAULT_NAME = T.let(:"<anonymous keyword splat>", Symbol)
+
+      sig { override.returns(Symbol) }
+      def decorated_name
+        :"**#{@name}"
+      end
+    end
+
+    # A block method parameter, e.g. `def foo(&block)`
+    class BlockParameter < Parameter
+      DEFAULT_NAME = T.let(:"<anonymous block>", Symbol)
+
+      sig { override.returns(Symbol) }
+      def decorated_name
+        :"&#{@name}"
+      end
     end
 
     class Member < Entry
@@ -203,17 +245,52 @@ module RubyIndexer
           end
         end
 
+        rest = parameters_node.rest
+
+        if rest.is_a?(Prism::RestParameterNode)
+          rest_name = rest.name || RestParameter::DEFAULT_NAME
+          parameters << RestParameter.new(name: rest_name)
+        end
+
+        keyword_rest = parameters_node.keyword_rest
+
+        if keyword_rest.is_a?(Prism::KeywordRestParameterNode)
+          keyword_rest_name = parameter_name(keyword_rest) || KeywordRestParameter::DEFAULT_NAME
+          parameters << KeywordRestParameter.new(name: keyword_rest_name)
+        end
+
+        parameters_node.posts.each do |post|
+          name = parameter_name(post)
+          next unless name
+
+          parameters << RequiredParameter.new(name: name)
+        end
+
+        block = parameters_node.block
+        parameters << BlockParameter.new(name: block.name || BlockParameter::DEFAULT_NAME) if block
+
         parameters
       end
 
-      sig { params(node: Prism::Node).returns(T.nilable(Symbol)) }
+      sig { params(node: T.nilable(Prism::Node)).returns(T.nilable(Symbol)) }
       def parameter_name(node)
         case node
         when Prism::RequiredParameterNode, Prism::OptionalParameterNode,
-          Prism::RequiredKeywordParameterNode, Prism::OptionalKeywordParameterNode
+          Prism::RequiredKeywordParameterNode, Prism::OptionalKeywordParameterNode,
+          Prism::RestParameterNode, Prism::KeywordRestParameterNode
           node.name
         when Prism::MultiTargetNode
-          names = [*node.lefts, *node.rest, *node.rights].map { |parameter_node| parameter_name(parameter_node) }
+          names = node.lefts.map { |parameter_node| parameter_name(parameter_node) }
+
+          rest = node.rest
+          if rest.is_a?(Prism::SplatNode)
+            name = rest.expression&.slice
+            names << (rest.operator == "*" ? "*#{name}".to_sym : name&.to_sym)
+          end
+
+          names << nil if rest.is_a?(Prism::ImplicitRestNode)
+
+          names.concat(node.rights.map { |parameter_node| parameter_name(parameter_node) })
 
           names_with_commas = names.join(", ")
           :"(#{names_with_commas})"

data/lib/ruby_indexer/test/method_test.rb

@@ -106,6 +106,142 @@ module RubyIndexer
       assert_instance_of(Entry::OptionalKeywordParameter, b)
     end
 
+    def test_method_with_rest_and_keyword_rest_parameters
+      index(<<~RUBY)
+        class Foo
+          def bar(*a, **b)
+          end
+        end
+      RUBY
+
+      assert_entry("bar", Entry::InstanceMethod, "/fake/path/foo.rb:1-2:2-5")
+      entry = T.must(@index["bar"].first)
+      assert_equal(2, entry.parameters.length)
+      a, b = entry.parameters
+
+      assert_equal(:a, a.name)
+      assert_instance_of(Entry::RestParameter, a)
+
+      assert_equal(:b, b.name)
+      assert_instance_of(Entry::KeywordRestParameter, b)
+    end
+
+    def test_method_with_post_parameters
+      index(<<~RUBY)
+        class Foo
+          def bar(*a, b)
+          end
+
+          def baz(**a, b)
+          end
+
+          def qux(*a, (b, c))
+        end
+      RUBY
+
+      assert_entry("bar", Entry::InstanceMethod, "/fake/path/foo.rb:1-2:2-5")
+      entry = T.must(@index["bar"].first)
+      assert_equal(2, entry.parameters.length)
+      a, b = entry.parameters
+
+      assert_equal(:a, a.name)
+      assert_instance_of(Entry::RestParameter, a)
+
+      assert_equal(:b, b.name)
+      assert_instance_of(Entry::RequiredParameter, b)
+
+      entry = T.must(@index["baz"].first)
+      assert_equal(2, entry.parameters.length)
+      a, b = entry.parameters
+
+      assert_equal(:a, a.name)
+      assert_instance_of(Entry::KeywordRestParameter, a)
+
+      assert_equal(:b, b.name)
+      assert_instance_of(Entry::RequiredParameter, b)
+
+      entry = T.must(@index["qux"].first)
+      assert_equal(2, entry.parameters.length)
+      _a, second = entry.parameters
+
+      assert_equal(:"(b, c)", second.name)
+      assert_instance_of(Entry::RequiredParameter, second)
+    end
+
+    def test_method_with_destructured_rest_parameters
+      index(<<~RUBY)
+        class Foo
+          def bar((a, *b))
+          end
+        end
+      RUBY
+
+      assert_entry("bar", Entry::InstanceMethod, "/fake/path/foo.rb:1-2:2-5")
+      entry = T.must(@index["bar"].first)
+      assert_equal(1, entry.parameters.length)
+      param = entry.parameters.first
+
+      assert_equal(:"(a, *b)", param.name)
+      assert_instance_of(Entry::RequiredParameter, param)
+    end
+
+    def test_method_with_block_parameters
+      index(<<~RUBY)
+        class Foo
+          def bar(&block)
+          end
+
+          def baz(&)
+          end
+        end
+      RUBY
+
+      entry = T.must(@index["bar"].first)
+      param = entry.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)
+
+      param = entry.parameters.first
+      assert_equal(Entry::BlockParameter::DEFAULT_NAME, param.name)
+      assert_instance_of(Entry::BlockParameter, param)
+    end
+
+    def test_method_with_anonymous_rest_parameters
+      index(<<~RUBY)
+        class Foo
+          def bar(*, **)
+          end
+        end
+      RUBY
+
+      assert_entry("bar", Entry::InstanceMethod, "/fake/path/foo.rb:1-2:2-5")
+      entry = T.must(@index["bar"].first)
+      assert_equal(2, entry.parameters.length)
+      first, second = entry.parameters
+
+      assert_equal(Entry::RestParameter::DEFAULT_NAME, first.name)
+      assert_instance_of(Entry::RestParameter, first)
+
+      assert_equal(Entry::KeywordRestParameter::DEFAULT_NAME, second.name)
+      assert_instance_of(Entry::KeywordRestParameter, second)
+    end
+
+    def test_method_with_forbidden_keyword_splat_parameter
+      index(<<~RUBY)
+        class Foo
+          def bar(**nil)
+          end
+        end
+      RUBY
+
+      assert_entry("bar", Entry::InstanceMethod, "/fake/path/foo.rb:1-2:2-5")
+      entry = T.must(@index["bar"].first)
+      assert_empty(entry.parameters)
+    end
+
     def test_keeps_track_of_method_owner
       index(<<~RUBY)
         class Foo

data/lib/ruby_lsp/document.rb

@@ -8,10 +8,6 @@ module RubyLsp
 
     abstract!
 
-    PositionShape = T.type_alias { { line: Integer, character: Integer } }
-    RangeShape = T.type_alias { { start: PositionShape, end: PositionShape } }
-    EditShape = T.type_alias { { range: RangeShape, text: String } }
-
     sig { returns(Prism::ParseResult) }
     attr_reader :parse_result
 
@@ -24,6 +20,9 @@ module RubyLsp
     sig { returns(URI::Generic) }
     attr_reader :uri
 
+    sig { returns(String) }
+    attr_reader :encoding
+
     sig { params(source: String, version: Integer, uri: URI::Generic, encoding: String).void }
     def initialize(source:, version:, uri:, encoding: Constant::PositionEncodingKind::UTF8)
       @cache = T.let({}, T::Hash[String, T.untyped])
@@ -77,7 +76,7 @@ module RubyLsp
       @cache[request_name]
     end
 
-    sig { params(edits: T::Array[EditShape], version: Integer).void }
+    sig { params(edits: T::Array[T::Hash[Symbol, T.untyped]], version: Integer).void }
     def push_edits(edits, version:)
       edits.each do |edit|
         range = edit[:range]
@@ -109,7 +108,7 @@ module RubyLsp
 
     sig do
       params(
-        position: PositionShape,
+        position: T::Hash[Symbol, T.untyped],
         node_types: T::Array[T.class_of(Prism::Node)],
       ).returns([T.nilable(Prism::Node), T.nilable(Prism::Node), T::Array[String]])
     end
@@ -190,7 +189,7 @@ module RubyLsp
       end
 
       # Finds the character index inside the source string for a given line and column
-      sig { params(position: PositionShape).returns(Integer) }
+      sig { params(position: T::Hash[Symbol, T.untyped]).returns(Integer) }
       def find_char_position(position)
         # Find the character index for the beginning of the requested line
         until @current_line == position[:line]

data/lib/ruby_lsp/executor.rb

@@ -25,6 +25,7 @@ module RubyLsp
       begin
         response = run(request)
       rescue StandardError, LoadError => e
+        warn(e.message)
         error = e
       end
 
@@ -98,7 +99,8 @@ module RubyLsp
         folding_range = Requests::FoldingRanges.new(document.parse_result.comments, dispatcher)
         document_symbol = Requests::DocumentSymbol.new(dispatcher)
         document_link = Requests::DocumentLink.new(uri, document.comments, dispatcher)
-        code_lens = Requests::CodeLens.new(uri, dispatcher)
+        lenses_configuration = T.must(@store.features_configuration.dig(:codeLens))
+        code_lens = Requests::CodeLens.new(uri, lenses_configuration, dispatcher)
 
         semantic_highlighting = Requests::SemanticHighlighting.new(dispatcher)
         dispatcher.dispatch(document.tree)
@@ -170,6 +172,8 @@ module RubyLsp
         completion(uri, request.dig(:params, :position))
       when "textDocument/definition"
         definition(uri, request.dig(:params, :position))
+      when "textDocument/signatureHelp"
+        signature_help(uri, request.dig(:params, :position), request.dig(:params, :context))
       when "workspace/didChangeWatchedFiles"
         did_change_watched_files(request.dig(:params, :changes))
       when "workspace/symbol"
@@ -239,12 +243,44 @@ module RubyLsp
       end
     end
 
+    sig do
+      params(
+        uri: URI::Generic,
+        position: T::Hash[Symbol, T.untyped],
+        context: T::Hash[Symbol, T.untyped],
+      ).returns(T.any(T.nilable(Interface::SignatureHelp), T::Hash[Symbol, T.untyped]))
+    end
+    def signature_help(uri, position, context)
+      current_signature = context[:activeSignatureHelp]
+      document = @store.get(uri)
+      target, parent, nesting = document.locate_node(
+        { line: position[:line], character: position[:character] - 2 },
+        node_types: [Prism::CallNode],
+      )
+
+      # If we're typing a nested method call (e.g.: `foo(bar)`), then we may end up locating `bar` as the target method
+      # call incorrectly. To correct that, we check if there's an active signature with the same name as the parent node
+      # and then replace the target
+      if current_signature && parent.is_a?(Prism::CallNode)
+        active_signature = current_signature[:activeSignature] || 0
+
+        if current_signature.dig(:signatures, active_signature, :label)&.start_with?(parent.message)
+          target = parent
+        end
+      end
+
+      dispatcher = Prism::Dispatcher.new
+      listener = Requests::SignatureHelp.new(context, nesting, @index, dispatcher)
+      dispatcher.dispatch_once(target)
+      listener.response
+    end
+
     sig { params(query: T.nilable(String)).returns(T::Array[Interface::WorkspaceSymbol]) }
     def workspace_symbol(query)
       Requests::WorkspaceSymbol.new(query, @index).run
     end
 
-    sig { params(uri: URI::Generic, range: T.nilable(Document::RangeShape)).returns({ ast: String }) }
+    sig { params(uri: URI::Generic, range: T.nilable(T::Hash[Symbol, T.untyped])).returns({ ast: String }) }
     def show_syntax_tree(uri, range)
       { ast: Requests::ShowSyntaxTree.new(@store.get(uri), range).run }
     end
@@ -252,7 +288,7 @@ module RubyLsp
     sig do
       params(
         uri: URI::Generic,
-        position: Document::PositionShape,
+        position: T::Hash[Symbol, T.untyped],
       ).returns(T.nilable(T.any(T::Array[Interface::Location], Interface::Location)))
     end
     def definition(uri, position)
@@ -273,7 +309,7 @@ module RubyLsp
     sig do
       params(
         uri: URI::Generic,
-        position: Document::PositionShape,
+        position: T::Hash[Symbol, T.untyped],
       ).returns(T.nilable(Interface::Hover))
     end
     def hover(uri, position)
@@ -300,7 +336,7 @@ module RubyLsp
     end
 
     sig do
-      params(uri: URI::Generic, content_changes: T::Array[Document::EditShape], version: Integer).returns(Object)
+      params(uri: URI::Generic, content_changes: T::Array[T::Hash[Symbol, T.untyped]], version: Integer).returns(Object)
     end
     def text_document_did_change(uri, content_changes, version)
       @store.push_edits(uri: uri, edits: content_changes, version: version)
@@ -322,7 +358,7 @@ module RubyLsp
     sig do
       params(
         uri: URI::Generic,
-        positions: T::Array[Document::PositionShape],
+        positions: T::Array[T::Hash[Symbol, T.untyped]],
       ).returns(T.nilable(T::Array[T.nilable(Requests::Support::SelectionRange)]))
     end
     def selection_range(uri, positions)
@@ -360,7 +396,7 @@ module RubyLsp
     sig do
       params(
         uri: URI::Generic,
-        position: Document::PositionShape,
+        position: T::Hash[Symbol, T.untyped],
         character: String,
       ).returns(T::Array[Interface::TextEdit])
     end
@@ -371,7 +407,7 @@ module RubyLsp
     sig do
       params(
         uri: URI::Generic,
-        position: Document::PositionShape,
+        position: T::Hash[Symbol, T.untyped],
       ).returns(T.nilable(T::Array[Interface::DocumentHighlight]))
     end
     def document_highlight(uri, position)
@@ -384,7 +420,12 @@ module RubyLsp
       listener.response
     end
 
-    sig { params(uri: URI::Generic, range: Document::RangeShape).returns(T.nilable(T::Array[Interface::InlayHint])) }
+    sig do
+      params(
+        uri: URI::Generic,
+        range: T::Hash[Symbol, T.untyped],
+      ).returns(T.nilable(T::Array[Interface::InlayHint]))
+    end
     def inlay_hint(uri, range)
       document = @store.get(uri)
 
@@ -392,7 +433,8 @@ module RubyLsp
       end_line = range.dig(:end, :line)
 
       dispatcher = Prism::Dispatcher.new
-      listener = Requests::InlayHints.new(start_line..end_line, dispatcher)
+      hints_configurations = T.must(@store.features_configuration.dig(:inlayHint))
+      listener = Requests::InlayHints.new(start_line..end_line, hints_configurations, dispatcher)
       dispatcher.visit(document.tree)
       listener.response
     end
@@ -400,7 +442,7 @@ module RubyLsp
     sig do
       params(
         uri: URI::Generic,
-        range: Document::RangeShape,
+        range: T::Hash[Symbol, T.untyped],
         context: T::Hash[Symbol, T.untyped],
       ).returns(T.nilable(T::Array[Interface::CodeAction]))
     end
@@ -454,7 +496,7 @@ module RubyLsp
       Interface::FullDocumentDiagnosticReport.new(kind: "full", items: response) if response
     end
 
-    sig { params(uri: URI::Generic, range: Document::RangeShape).returns(Interface::SemanticTokens) }
+    sig { params(uri: URI::Generic, range: T::Hash[Symbol, T.untyped]).returns(Interface::SemanticTokens) }
     def semantic_tokens_range(uri, range)
       document = @store.get(uri)
       start_line = range.dig(:start, :line)
@@ -470,7 +512,7 @@ module RubyLsp
     sig do
       params(
         uri: URI::Generic,
-        position: Document::PositionShape,
+        position: T::Hash[Symbol, T.untyped],
       ).returns(T.nilable(T::Array[Interface::CompletionItem]))
     end
     def completion(uri, position)
@@ -602,6 +644,11 @@ module RubyLsp
       configured_features = options.dig(:initializationOptions, :enabledFeatures)
       @store.experimental_features = options.dig(:initializationOptions, :experimentalFeaturesEnabled) || false
 
+      configured_hints = options.dig(:initializationOptions, :featuresConfiguration, :inlayHint)
+      configured_lenses = options.dig(:initializationOptions, :featuresConfiguration, :codeLens)
+      T.must(@store.features_configuration.dig(:inlayHint)).configuration.merge!(configured_hints) if configured_hints
+      T.must(@store.features_configuration.dig(:codeLens)).configuration.merge!(configured_lenses) if configured_lenses
+
       enabled_features = case configured_features
       when Array
         # If the configuration is using an array, then absent features are disabled and present ones are enabled. That's
@@ -663,7 +710,7 @@ module RubyLsp
       on_type_formatting_provider = if enabled_features["onTypeFormatting"]
         Interface::DocumentOnTypeFormattingOptions.new(
           first_trigger_character: "{",
-          more_trigger_character: ["\n", "|"],
+          more_trigger_character: ["\n", "|", "d"],
         )
       end
 
@@ -685,6 +732,13 @@ module RubyLsp
         )
       end
 
+      signature_help_provider = if enabled_features["signatureHelp"]
+        # Identifier characters are automatically included, such as A-Z, a-z, 0-9, _, * or :
+        Interface::SignatureHelpOptions.new(
+          trigger_characters: ["(", " ", ","],
+        )
+      end
+
       # Dynamically registered capabilities
       file_watching_caps = options.dig(:capabilities, :workspace, :didChangeWatchedFiles)
 
@@ -737,6 +791,7 @@ module RubyLsp
           code_lens_provider: code_lens_provider,
           definition_provider: enabled_features["definition"],
           workspace_symbol_provider: enabled_features["workspaceSymbol"],
+          signature_help_provider: signature_help_provider,
         ),
         serverInfo: {
           name: "Ruby LSP",

data/lib/ruby_lsp/requests/code_action_resolve.rb

@@ -137,7 +137,7 @@ module RubyLsp
 
       private
 
-      sig { params(range: Document::RangeShape, new_text: String).returns(Interface::TextEdit) }
+      sig { params(range: T::Hash[Symbol, T.untyped], new_text: String).returns(Interface::TextEdit) }
       def create_text_edit(range, new_text)
         Interface::TextEdit.new(
           range: Interface::Range.new(

data/lib/ruby_lsp/requests/code_actions.rb

@@ -22,7 +22,7 @@ module RubyLsp
       sig do
         params(
           document: Document,
-          range: Document::RangeShape,
+          range: T::Hash[Symbol, T.untyped],
           context: T::Hash[Symbol, T.untyped],
         ).void
       end
@@ -38,14 +38,8 @@ module RubyLsp
       def run
         diagnostics = @context[:diagnostics]
 
-        code_actions = diagnostics.filter_map do |diagnostic|
-          code_action = diagnostic.dig(:data, :code_action)
-          next if code_action.nil?
-
-          # We want to return only code actions that are within range or that do not have any edits, such as refactor
-          # code actions
-          range = code_action.dig(:edit, :documentChanges, 0, :edits, 0, :range)
-          code_action if diagnostic.dig(:data, :correctable) && cover?(range)
+        code_actions = diagnostics.flat_map do |diagnostic|
+          diagnostic.dig(:data, :code_actions) || []
         end
 
         # Only add refactor actions if there's a non empty selection in the editor
@@ -55,15 +49,7 @@ module RubyLsp
 
       private
 
-      sig { params(range: T.nilable(Document::RangeShape)).returns(T::Boolean) }
-      def cover?(range)
-        range.nil? ||
-          ((@range.dig(:start, :line))..(@range.dig(:end, :line))).cover?(
-            (range.dig(:start, :line))..(range.dig(:end, :line)),
-          )
-      end
-
-      sig { params(range: Document::RangeShape, uri: URI::Generic).returns(Interface::CodeAction) }
+      sig { params(range: T::Hash[Symbol, T.untyped], uri: URI::Generic).returns(Interface::CodeAction) }
       def refactor_code_action(range, uri)
         Interface::CodeAction.new(
           title: "Refactor: Extract Variable",

data/lib/ruby_lsp/requests/code_lens.rb

@@ -11,6 +11,10 @@ module RubyLsp
     # [code lens](https://microsoft.github.io/language-server-protocol/specification#textDocument_codeLens)
     # request informs the editor of runnable commands such as tests
     #
+    # # Configuration
+    #
+    # To disable gem code lenses, set `rubyLsp.featuresConfiguration.codeLens.gemfileLinks` to `false`.
+    #
     # # Example
     #
     # ```ruby
@@ -47,8 +51,14 @@ module RubyLsp
       sig { override.returns(ResponseType) }
       attr_reader :_response
 
-      sig { params(uri: URI::Generic, dispatcher: Prism::Dispatcher).void }
-      def initialize(uri, dispatcher)
+      sig do
+        params(
+          uri: URI::Generic,
+          lenses_configuration: RequestConfig,
+          dispatcher: Prism::Dispatcher,
+        ).void
+      end
+      def initialize(uri, lenses_configuration, dispatcher)
         @uri = T.let(uri, URI::Generic)
         @_response = T.let([], ResponseType)
         @path = T.let(uri.to_standardized_path, T.nilable(String))
@@ -57,6 +67,7 @@ module RubyLsp
         @class_stack = T.let([], T::Array[String])
         @group_id = T.let(1, Integer)
         @group_id_stack = T.let([], T::Array[Integer])
+        @lenses_configuration = lenses_configuration
 
         super(dispatcher)
 
@@ -134,6 +145,8 @@ module RubyLsp
         end
 
         if @path&.include?(GEMFILE_NAME) && name == :gem && arguments
+          return unless @lenses_configuration.enabled?(:gemfileLinks)
+
           first_argument = arguments.arguments.first
           return unless first_argument.is_a?(Prism::StringNode)
 

data/lib/ruby_lsp/requests/completion.rb

@@ -154,13 +154,11 @@ module RubyLsp
       end
       def build_method_completion(entry, node)
         name = entry.name
-        parameters = entry.parameters
-        new_text = parameters.empty? ? name : "#{name}(#{parameters.map(&:name).join(", ")})"
 
         Interface::CompletionItem.new(
           label: name,
           filter_text: name,
-          text_edit: Interface::TextEdit.new(range: range_from_node(node), new_text: new_text),
+          text_edit: Interface::TextEdit.new(range: range_from_node(node), new_text: name),
           kind: Constant::CompletionItemKind::METHOD,
           label_details: Interface::CompletionItemLabelDetails.new(
             description: entry.file_name,

data/lib/ruby_lsp/requests/inlay_hints.rb

@@ -9,6 +9,14 @@ module RubyLsp
     # are labels added directly in the code that explicitly show the user something that might
     # otherwise just be implied.
     #
+    # # Configuration
+    #
+    # To enable rescue hints, set `rubyLsp.featuresConfiguration.inlayHint.implicitRescue` to `true`.
+    #
+    # To enable hash value hints, set `rubyLsp.featuresConfiguration.inlayHint.implicitHashValue` to `true`.
+    #
+    # To enable all hints, set `rubyLsp.featuresConfiguration.inlayHint.enableAll` to `true`.
+    #
     # # Example
     #
     # ```ruby
@@ -39,18 +47,26 @@ module RubyLsp
       sig { override.returns(ResponseType) }
       attr_reader :_response
 
-      sig { params(range: T::Range[Integer], dispatcher: Prism::Dispatcher).void }
-      def initialize(range, dispatcher)
+      sig do
+        params(
+          range: T::Range[Integer],
+          hints_configuration: RequestConfig,
+          dispatcher: Prism::Dispatcher,
+        ).void
+      end
+      def initialize(range, hints_configuration, dispatcher)
         super(dispatcher)
 
         @_response = T.let([], ResponseType)
         @range = range
+        @hints_configuration = hints_configuration
 
         dispatcher.register(self, :on_rescue_node_enter, :on_implicit_node_enter)
       end
 
       sig { params(node: Prism::RescueNode).void }
       def on_rescue_node_enter(node)
+        return unless @hints_configuration.enabled?(:implicitRescue)
         return unless node.exceptions.empty?
 
         loc = node.location
@@ -66,6 +82,7 @@ module RubyLsp
 
       sig { params(node: Prism::ImplicitNode).void }
       def on_implicit_node_enter(node)
+        return unless @hints_configuration.enabled?(:implicitHashValue)
         return unless visible?(node, @range)
 
         node_value = node.value

data/lib/ruby_lsp/requests/on_type_formatting.rb

@@ -26,7 +26,7 @@ module RubyLsp
         T::Array[Regexp],
       )
 
-      sig { params(document: Document, position: Document::PositionShape, trigger_character: String).void }
+      sig { params(document: Document, position: T::Hash[Symbol, T.untyped], trigger_character: String).void }
       def initialize(document, position, trigger_character)
         super(document)
 
@@ -60,6 +60,8 @@ module RubyLsp
               handle_statement_end
             end
           end
+        when "d"
+          auto_indent_after_end_keyword
         end
 
         @edits
@@ -118,7 +120,7 @@ module RubyLsp
         current_line = @lines[@position[:line]]
         next_line = @lines[@position[:line] + 1]
 
-        if current_line.nil? || current_line.strip.empty?
+        if current_line.nil? || current_line.strip.empty? || current_line.include?(")") || current_line.include?("]")
           add_edit_with_text("\n")
           add_edit_with_text("#{indents}end")
           move_cursor_to(@position[:line], @indentation + 2)
@@ -141,7 +143,7 @@ module RubyLsp
         add_edit_with_text("##{spaces}")
       end
 
-      sig { params(text: String, position: Document::PositionShape).void }
+      sig { params(text: String, position: T::Hash[Symbol, T.untyped]).void }
       def add_edit_with_text(text, position = @position)
         pos = Interface::Position.new(
           line: position[:line],
@@ -185,6 +187,32 @@ module RubyLsp
 
         count
       end
+
+      sig { void }
+      def auto_indent_after_end_keyword
+        current_line = @lines[@position[:line]]
+        return unless current_line&.strip == "end"
+
+        target, _parent, _nesting = @document.locate_node({
+          line: @position[:line],
+          character: @position[:character] - 1,
+        })
+
+        statements = case target
+        when Prism::IfNode, Prism::UnlessNode, Prism::ForNode, Prism::WhileNode, Prism::UntilNode
+          target.statements
+        end
+        return unless statements
+
+        statements.body.each do |node|
+          loc = node.location
+          next unless loc.start_column == @indentation
+
+          add_edit_with_text("  ", { line: loc.start_line - 1, character: 0 })
+        end
+
+        move_cursor_to(@position[:line], @position[:character])
+      end
     end
   end
 end

data/lib/ruby_lsp/requests/show_syntax_tree.rb

@@ -20,7 +20,7 @@ module RubyLsp
     class ShowSyntaxTree < BaseRequest
       extend T::Sig
 
-      sig { params(document: Document, range: T.nilable(Document::RangeShape)).void }
+      sig { params(document: Document, range: T.nilable(T::Hash[Symbol, T.untyped])).void }
       def initialize(document, range)
         super(document)
 

data/lib/ruby_lsp/requests/signature_help.rb

@@ -0,0 +1,95 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  module Requests
+    # ![Signature help demo](../../signature_help.gif)
+    #
+    # The [signature help
+    # request](https://microsoft.github.io/language-server-protocol/specification#textDocument_signatureHelp) displays
+    # information about the parameters of a method as you type an invocation.
+    #
+    # Currently only supports methods invoked directly on `self` without taking inheritance into account.
+    #
+    # # Example
+    #
+    # ```ruby
+    # class Foo
+    #  def bar(a, b, c)
+    #  end
+    #
+    #  def baz
+    #    bar( # -> Signature help will show the parameters of `bar`
+    #  end
+    # ```
+    class SignatureHelp < Listener
+      extend T::Sig
+      extend T::Generic
+
+      ResponseType = type_member { { fixed: T.nilable(T.any(Interface::SignatureHelp, T::Hash[Symbol, T.untyped])) } }
+
+      sig { override.returns(ResponseType) }
+      attr_reader :_response
+
+      sig do
+        params(
+          context: T::Hash[Symbol, T.untyped],
+          nesting: T::Array[String],
+          index: RubyIndexer::Index,
+          dispatcher: Prism::Dispatcher,
+        ).void
+      end
+      def initialize(context, nesting, index, dispatcher)
+        @context = context
+        @nesting = nesting
+        @index = index
+        @_response = T.let(nil, ResponseType)
+
+        super(dispatcher)
+        dispatcher.register(self, :on_call_node_enter)
+      end
+
+      sig { params(node: Prism::CallNode).void }
+      def on_call_node_enter(node)
+        return if DependencyDetector.instance.typechecker
+        return unless self_receiver?(node)
+
+        message = node.message
+        return unless message
+
+        target_method = @index.resolve_method(message, @nesting.join("::"))
+        return unless target_method
+
+        parameters = target_method.parameters
+        name = target_method.name
+
+        # If the method doesn't have any parameters, there's no need to show signature help
+        return if parameters.empty?
+
+        label = "#{name}(#{parameters.map(&:decorated_name).join(", ")})"
+
+        arguments_node = node.arguments
+        arguments = arguments_node&.arguments || []
+        active_parameter = (arguments.length - 1).clamp(0, parameters.length - 1)
+
+        # If there are arguments, then we need to check if there's a trailing comma after the end of the last argument
+        # to advance the active parameter to the next one
+        if arguments_node &&
+            node.slice.byteslice(arguments_node.location.end_offset - node.location.start_offset) == ","
+          active_parameter += 1
+        end
+
+        @_response = Interface::SignatureHelp.new(
+          signatures: [
+            Interface::SignatureInformation.new(
+              label: label,
+              parameters: parameters.map { |param| Interface::ParameterInformation.new(label: param.name) },
+              documentation: markdown_from_index_entries("", target_method),
+            ),
+          ],
+          active_parameter: active_parameter,
+        )
+      end
+    end
+  end
+end

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

@@ -19,30 +19,23 @@ module RubyLsp
           T::Hash[Symbol, Integer],
         )
 
-        sig { params(offense: RuboCop::Cop::Offense, uri: URI::Generic).void }
-        def initialize(offense, uri)
+        # TODO: avoid passing document once we have alternative ways to get at
+        # encoding and file source
+        sig { params(document: Document, offense: RuboCop::Cop::Offense, uri: URI::Generic).void }
+        def initialize(document, offense, uri)
+          @document = document
           @offense = offense
           @uri = uri
         end
 
-        sig { returns(Interface::CodeAction) }
-        def to_lsp_code_action
-          Interface::CodeAction.new(
-            title: "Autocorrect #{@offense.cop_name}",
-            kind: Constant::CodeActionKind::QUICK_FIX,
-            edit: Interface::WorkspaceEdit.new(
-              document_changes: [
-                Interface::TextDocumentEdit.new(
-                  text_document: Interface::OptionalVersionedTextDocumentIdentifier.new(
-                    uri: @uri.to_s,
-                    version: nil,
-                  ),
-                  edits: @offense.correctable? ? offense_replacements : [],
-                ),
-              ],
-            ),
-            is_preferred: true,
-          )
+        sig { returns(T::Array[Interface::CodeAction]) }
+        def to_lsp_code_actions
+          code_actions = []
+
+          code_actions << autocorrect_action if @offense.correctable?
+          code_actions << disable_line_action
+
+          code_actions
         end
 
         sig { returns(Interface::Diagnostic) }
@@ -65,7 +58,7 @@ module RubyLsp
             ),
             data: {
               correctable: @offense.correctable?,
-              code_action: to_lsp_code_action,
+              code_actions: to_lsp_code_actions,
             },
           )
         end
@@ -90,6 +83,26 @@ module RubyLsp
           Interface::CodeDescription.new(href: doc_url) if doc_url
         end
 
+        sig { returns(Interface::CodeAction) }
+        def autocorrect_action
+          Interface::CodeAction.new(
+            title: "Autocorrect #{@offense.cop_name}",
+            kind: Constant::CodeActionKind::QUICK_FIX,
+            edit: Interface::WorkspaceEdit.new(
+              document_changes: [
+                Interface::TextDocumentEdit.new(
+                  text_document: Interface::OptionalVersionedTextDocumentIdentifier.new(
+                    uri: @uri.to_s,
+                    version: nil,
+                  ),
+                  edits: @offense.correctable? ? offense_replacements : [],
+                ),
+              ],
+            ),
+            is_preferred: true,
+          )
+        end
+
         sig { returns(T::Array[Interface::TextEdit]) }
         def offense_replacements
           @offense.corrector.as_replacements.map do |range, replacement|
@@ -102,6 +115,64 @@ module RubyLsp
             )
           end
         end
+
+        sig { returns(Interface::CodeAction) }
+        def disable_line_action
+          Interface::CodeAction.new(
+            title: "Disable #{@offense.cop_name} for this line",
+            kind: Constant::CodeActionKind::QUICK_FIX,
+            edit: Interface::WorkspaceEdit.new(
+              document_changes: [
+                Interface::TextDocumentEdit.new(
+                  text_document: Interface::OptionalVersionedTextDocumentIdentifier.new(
+                    uri: @uri.to_s,
+                    version: nil,
+                  ),
+                  edits: line_disable_comment,
+                ),
+              ],
+            ),
+          )
+        end
+
+        sig { returns(T::Array[Interface::TextEdit]) }
+        def line_disable_comment
+          new_text = if @offense.source_line.include?(" # rubocop:disable ")
+            ",#{@offense.cop_name}"
+          else
+            " # rubocop:disable #{@offense.cop_name}"
+          end
+
+          eol = Interface::Position.new(
+            line: @offense.line - 1,
+            character: length_of_line(@offense.source_line),
+          )
+
+          # TODO: fails for multiline strings - may be preferable to use block
+          # comments to disable some offenses
+          inline_comment = Interface::TextEdit.new(
+            range: Interface::Range.new(start: eol, end: eol),
+            new_text: new_text,
+          )
+
+          [inline_comment]
+        end
+
+        sig { params(line: String).returns(Integer) }
+        def length_of_line(line)
+          if @document.encoding == Constant::PositionEncodingKind::UTF16
+            line_length = 0
+            line.codepoints.each do |codepoint|
+              line_length += 1
+              if codepoint > RubyLsp::Document::Scanner::SURROGATE_PAIR_START
+                line_length += 1
+              end
+            end
+            line_length
+          else
+            line.length
+          end
+        end
       end
     end
   end

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

@@ -25,7 +25,7 @@ module RubyLsp
           @runner.run(filename, document.source)
 
           @runner.offenses.map do |offense|
-            Support::RuboCopDiagnostic.new(offense, uri)
+            Support::RuboCopDiagnostic.new(document, offense, uri)
           end
         end
       end

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

@@ -7,7 +7,7 @@ module RubyLsp
       class SelectionRange < Interface::SelectionRange
         extend T::Sig
 
-        sig { params(position: Document::PositionShape).returns(T::Boolean) }
+        sig { params(position: T::Hash[Symbol, T.untyped]).returns(T::Boolean) }
         def cover?(position)
           start_covered = range.start.line < position[:line] ||
             (range.start.line == position[:line] && range.start.character <= position[:character])

data/lib/ruby_lsp/requests.rb

@@ -22,6 +22,7 @@ module RubyLsp
   # - [Definition](rdoc-ref:RubyLsp::Requests::Definition)
   # - [ShowSyntaxTree](rdoc-ref:RubyLsp::Requests::ShowSyntaxTree)
   # - [WorkspaceSymbol](rdoc-ref:RubyLsp::Requests::WorkspaceSymbol)
+  # - [SignatureHelp](rdoc-ref:RubyLsp::Requests::SignatureHelp)
 
   module Requests
     autoload :BaseRequest, "ruby_lsp/requests/base_request"
@@ -43,6 +44,7 @@ module RubyLsp
     autoload :Definition, "ruby_lsp/requests/definition"
     autoload :ShowSyntaxTree, "ruby_lsp/requests/show_syntax_tree"
     autoload :WorkspaceSymbol, "ruby_lsp/requests/workspace_symbol"
+    autoload :SignatureHelp, "ruby_lsp/requests/signature_help"
 
     # :nodoc:
     module Support

data/lib/ruby_lsp/store.rb

@@ -20,6 +20,9 @@ module RubyLsp
     sig { returns(URI::Generic) }
     attr_accessor :workspace_uri
 
+    sig { returns(T::Hash[Symbol, RequestConfig]) }
+    attr_accessor :features_configuration
+
     sig { void }
     def initialize
       @state = T.let({}, T::Hash[String, Document])
@@ -28,6 +31,20 @@ module RubyLsp
       @supports_progress = T.let(true, T::Boolean)
       @experimental_features = T.let(false, T::Boolean)
       @workspace_uri = T.let(URI::Generic.from_path(path: Dir.pwd), URI::Generic)
+      @features_configuration = T.let(
+        {
+          codeLens: RequestConfig.new({
+            enableAll: false,
+            gemfileLinks: true,
+          }),
+          inlayHint: RequestConfig.new({
+            enableAll: false,
+            implicitRescue: false,
+            implicitHashValue: false,
+          }),
+        },
+        T::Hash[Symbol, RequestConfig],
+      )
     end
 
     sig { params(uri: URI::Generic).returns(Document) }
@@ -46,7 +63,7 @@ module RubyLsp
       @state[uri.to_s] = document
     end
 
-    sig { params(uri: URI::Generic, edits: T::Array[Document::EditShape], version: Integer).void }
+    sig { params(uri: URI::Generic, edits: T::Array[T::Hash[Symbol, T.untyped]], version: Integer).void }
     def push_edits(uri:, edits:, version:)
       T.must(@state[uri.to_s]).push_edits(edits, version: version)
     end

data/lib/ruby_lsp/utils.rb

@@ -74,4 +74,22 @@ module RubyLsp
       @cancelled = true
     end
   end
+
+  # A request configuration, to turn on/off features
+  class RequestConfig
+    extend T::Sig
+
+    sig { returns(T::Hash[Symbol, T::Boolean]) }
+    attr_accessor :configuration
+
+    sig { params(configuration: T::Hash[Symbol, T::Boolean]).void }
+    def initialize(configuration)
+      @configuration = configuration
+    end
+
+    sig { params(feature: Symbol).returns(T.nilable(T::Boolean)) }
+    def enabled?(feature)
+      @configuration[:enableAll] || @configuration[feature]
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-lsp
 version: !ruby/object:Gem::Version
-  version: 0.13.0
+  version: 0.13.2
 platform: ruby
 authors:
 - Shopify
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-11-30 00:00:00.000000000 Z
+date: 2023-12-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: language_server-protocol
@@ -30,20 +30,20 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.18.0
+        version: 0.19.0
     - - "<"
       - !ruby/object:Gem::Version
-        version: '0.19'
+        version: '0.20'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.18.0
+        version: 0.19.0
     - - "<"
       - !ruby/object:Gem::Version
-        version: '0.19'
+        version: '0.20'
 - !ruby/object:Gem::Dependency
   name: sorbet-runtime
   requirement: !ruby/object:Gem::Requirement
@@ -118,6 +118,7 @@ files:
 - lib/ruby_lsp/requests/selection_ranges.rb
 - lib/ruby_lsp/requests/semantic_highlighting.rb
 - lib/ruby_lsp/requests/show_syntax_tree.rb
+- lib/ruby_lsp/requests/signature_help.rb
 - lib/ruby_lsp/requests/support/annotation.rb
 - lib/ruby_lsp/requests/support/common.rb
 - lib/ruby_lsp/requests/support/dependency_detector.rb
@@ -157,7 +158,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.21
+rubygems_version: 3.4.22
 signing_key: 
 specification_version: 4
 summary: An opinionated language server for Ruby