solargraph 0.59.0 → 0.59.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 48702da784ad5e4ba9333e3389532a20af5bd0474cde01f0b00b9b07a53203ce
-  data.tar.gz: 93df9a47dde759e2de2f92f6e65609e4de5ba83403c4f481915e984d05111bab
+  metadata.gz: 9346852d9ba48c677a63c6ac2dd3bf6b7cb536309f28569c256bc8654c19c865
+  data.tar.gz: 9fd017aedc2b705156999d93f5bc8f5f6b99cd7cc3716565ef42ab26936336eb
 SHA512:
-  metadata.gz: 40c2a0be04ee36e8c0c7328e51e751c04becaddd5f405a302ec369bb7bae365705f75bf3852c1c99183e8ac00d58a61177216e75f60b2af9fb0d064c95496715
-  data.tar.gz: 41c1a1dd7c926debbb79a8f63b24e550d6b3a389ad71f09e392ce8216b66fa33b73d2a6269d5b624ecdf5aa86add0a81e40c2b3b24483a4555fb3a53d61e1e9c
+  metadata.gz: 5b8d3c627dec8757b70444e444a66dd024818f3e62e7c8d9ea57a638182de64524cca532c7b8ae9c5944d373cfdb2e0f3a1ede46e1e8b3e4e728d02b2f9db0e0
+  data.tar.gz: 41321b8ad277092a434241bc099488c99c721fb7bf593cb3c41f703329ba2d90e2416b5f407ed858db69776d02eb9bb3c93025d094de6f4413fd368f933a7398

data/.github/workflows/plugins.yml

@@ -23,7 +23,7 @@ jobs:
     - name: Set up Ruby
       uses: ruby/setup-ruby@v1
       with:
-        ruby-version: 3.4 # keep same as typecheck.yml
+        ruby-version: 4.0 # keep same as typecheck.yml
         bundler-cache: true
     - uses: awalsh128/cache-apt-pkgs-action@latest
       with:

data/.github/workflows/typecheck.yml

@@ -27,7 +27,7 @@ jobs:
     - name: Set up Ruby
       uses: ruby/setup-ruby@v1
       with:
-        ruby-version: 3.4
+        ruby-version: 4.0
         bundler-cache: false
     - name: Install gems
       run: |

data/CHANGELOG.md

@@ -1,3 +1,8 @@
+## 0.59.1 - May 18, 2026
+- Fix signatureHelp bug (#1185)
+- Linting fixes for Ruby 3.1 (#1193)
+- Parameters shadow local variables with same name (#1192)
+
 ## 0.59.0 - May 13, 2026
 - Ensure pathname is required for rbs in shell caching processes (#1183)
 - Pre-release branch 2026-01-12 (#1152)

data/lib/solargraph/complex_type/unique_type.rb

@@ -482,8 +482,8 @@ module Solargraph
       # @yieldparam t [self]
       # @yieldreturn [self]
       # @return [Enumerable<self>]
-      def each &block
-        [self].each(&block)
+      def each(&)
+        [self].each(&)
       end
 
       # @return [Array<UniqueType>]

data/lib/solargraph/complex_type.rb

@@ -166,7 +166,7 @@ module Solargraph
     # @param name [Symbol]
     # @param include_private [Boolean]
     def respond_to_missing? name, include_private = false
-      TypeMethods.public_instance_methods.include?(name) || super
+      TypeMethods.public_method_defined?(name) || super
     end
 
     def to_s

data/lib/solargraph/language_server/host.rb

@@ -648,15 +648,14 @@ module Solargraph
       # @param text [String]
       # @param type [Integer] A MessageType constant
       # @param actions [Array<String>] Response options for the client
-      # @param block [Proc] The block that processes the response
       # @yieldparam [String] The action received from the client
       # @return [void]
-      def show_message_request text, type, actions, &block
-        send_request 'window/showMessageRequest', {
-          type: type,
-          message: text,
-          actions: actions
-        }, &block
+      def show_message_request(text, type, actions, &)
+        send_request('window/showMessageRequest', {
+                       type: type,
+                       message: text,
+                       actions: actions
+                     }, &)
       end
 
       # Get a list of IDs for server requests that are waiting for responses

data/lib/solargraph/parser/parser_gem/node_methods.rb

@@ -4,6 +4,7 @@ require 'parser'
 require 'ast'
 
 # https://github.com/whitequark/parser
+# rubocop:disable Metrics/ModuleLength
 module Solargraph
   module Parser
     module ParserGem
@@ -246,15 +247,100 @@ module Solargraph
             end
             prev = node
           end
-          nil
+          find_recipient_node_by_text(source, offset)
+        end
+
+        # Text-based fallback for finding a method call recipient when the AST
+        # is unavailable (e.g., unparseable source with syntax errors).
+        #
+        # Scans backward from cursor offset to find '(' and the method name
+        # before it, then creates a minimal :send node.
+        #
+        # @param source [Solargraph::Source]
+        # @param offset [Integer]
+        # @return [Parser::AST::Node, nil]
+        def find_recipient_node_by_text source, offset
+          code = source.code
+          return nil if offset.nil? || offset <= 0 || offset > code.length
+
+          # The '(' could be at offset-1 (cursor after '(') or at offset (cursor on '(')
+          start_pos = offset - 1
+          if start_pos.positive? && code[start_pos] != '(' && code[offset] == '('
+            start_pos = offset
+          end
+
+          # Scan backward to find the matching '(' (handle nested parens)
+          depth = 0
+          paren_pos = nil
+          pos = start_pos
+          while pos >= 0
+            case code[pos]
+            when ')'
+              depth += 1
+            when '('
+              if depth.zero?
+                paren_pos = pos
+                break
+              end
+              depth -= 1
+            end
+            pos -= 1
+          end
+          return nil if paren_pos.nil?
+
+          # Skip whitespace before '(' to find method name
+          idx = paren_pos - 1
+          idx -= 1 while idx >= 0 && code[idx] =~ /\s/
+          return nil if idx.negative?
+
+          # Read method name (including ? and !)
+          name_end = idx + 1
+          idx -= 1 while idx >= 0 && code[idx] =~ /[a-zA-Z0-9_?!]/
+          name_start = idx + 1
+          return nil if name_start >= name_end
+          method_name = code[name_start...name_end]
+          return nil if method_name.empty?
+
+          # Check for receiver pattern: receiver.method( or receiver::method(
+          idx = name_start - 1
+          idx -= 1 while idx >= 0 && code[idx] =~ /\s/
+          if idx >= 0 && code[idx] == '.'
+            idx -= 1
+            idx -= 1 while idx >= 0 && code[idx] =~ /\s/
+            recv_end = idx + 1
+            idx -= 1 while idx >= 0 && code[idx] =~ /[a-zA-Z0-9_@$]/
+            recv_start = idx + 1
+            if recv_start < recv_end
+              recv_name = code[recv_start...recv_end]
+              unless recv_name.empty?
+                receiver_node = ::Parser::AST::Node.new(:send, [nil, recv_name.to_sym])
+                return ::Parser::AST::Node.new(:send, [receiver_node, method_name.to_sym])
+              end
+            end
+          elsif idx >= 0 && idx.positive? && code[idx - 1] == ':' && code[idx] == ':'
+            const_end = idx - 1
+            const_start = const_end
+            const_start -= 1 while const_start.positive? && code[const_start - 1] =~ /[a-zA-Z0-9_]/
+            const_name = code[const_start...const_end]
+            unless const_name.empty? || method_name.empty?
+              const_node = ::Parser::AST::Node.new(:const, [nil, const_name.to_sym])
+              return ::Parser::AST::Node.new(:send, [const_node, method_name.to_sym])
+            end
+          end
+
+          # Simple method call without receiver
+          ::Parser::AST::Node.new(:send, [nil, method_name.to_sym])
         end
 
         # @param cursor [Solargraph::Source::Cursor]
         # @return [Parser::AST::Node, nil]
         def repaired_find_recipient_node cursor
-          cursor = cursor.source.cursor_at([cursor.position.line, cursor.position.column - 1])
-          node = cursor.source.tree_at(cursor.position.line, cursor.position.column).first
-          node if node && node.type == :send
+          c = cursor.source.cursor_at([cursor.position.line, cursor.position.column - 1])
+          tree = c.source.tree_at(c.position.line, c.position.column)
+          tree.each do |node|
+            return node if node.type == :send
+          end
+          find_recipient_node_by_text(cursor.source, cursor.offset)
         end
 
         #
@@ -505,3 +591,4 @@ module Solargraph
     end
   end
 end
+# rubocop:enable Metrics/ModuleLength

data/lib/solargraph/parser/parser_gem/node_processors/namespace_node.rb

@@ -1,40 +1,40 @@
-# frozen_string_literal: true
-
-module Solargraph
-  module Parser
-    module ParserGem
-      module NodeProcessors
-        class NamespaceNode < Parser::NodeProcessor::Base
-          include ParserGem::NodeMethods
-
-          def process
-            superclass_name = nil
-            superclass_name = unpack_name(node.children[1]) if node.type == :class && node.children[1]&.type == :const
-
-            loc = get_node_location(node)
-            nspin = Solargraph::Pin::Namespace.new(
-              type: node.type,
-              location: loc,
-              closure: region.closure,
-              name: unpack_name(node.children[0]),
-              comments: comments_for(node),
-              visibility: :public,
-              gates: region.closure.gates.freeze,
-              source: :parser
-            )
-            pins.push nspin
-            unless superclass_name.nil?
-              pins.push Pin::Reference::Superclass.new(
-                location: loc,
-                closure: pins.last,
-                name: superclass_name,
-                source: :parser
-              )
-            end
-            process_children region.update(closure: nspin, visibility: :public)
-          end
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Solargraph
+  module Parser
+    module ParserGem
+      module NodeProcessors
+        class NamespaceNode < Parser::NodeProcessor::Base
+          include ParserGem::NodeMethods
+
+          def process
+            superclass_name = nil
+            superclass_name = unpack_name(node.children[1]) if node.type == :class && node.children[1]&.type == :const
+
+            loc = get_node_location(node)
+            nspin = Solargraph::Pin::Namespace.new(
+              type: node.type,
+              location: loc,
+              closure: region.closure,
+              name: unpack_name(node.children[0]),
+              comments: comments_for(node),
+              visibility: :public,
+              gates: region.closure.gates.freeze,
+              source: :parser
+            )
+            pins.push nspin
+            unless superclass_name.nil?
+              pins.push Pin::Reference::Superclass.new(
+                location: loc,
+                closure: pins.last,
+                name: superclass_name,
+                source: :parser
+              )
+            end
+            process_children region.update(closure: nspin, visibility: :public)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/pin/base.rb

@@ -293,7 +293,7 @@ module Solargraph
       # @param attr [::Symbol]
       # @return [void]
       # @todo strong typechecking should complain when there are no block-related tags
-      def assert_same_array_content other, attr, &block
+      def assert_same_array_content(other, attr, &)
         arr1 = send(attr)
         raise "Expected #{attr} on #{self} to be an Enumerable, got #{arr1.class}" unless arr1.is_a?(::Enumerable)
         # @type arr1 [::Enumerable]
@@ -302,9 +302,9 @@ module Solargraph
         # @type arr2 [::Enumerable]
 
         # @type [undefined]
-        values1 = arr1.map(&block)
+        values1 = arr1.map(&)
         # @type [undefined]
-        values2 = arr2.map(&block)
+        values2 = arr2.map(&)
         # @sg-ignore
         return arr1 if values1 == values2
         Solargraph.assert_or_log(:"combine_with_#{attr}",

data/lib/solargraph/pin/method.rb

@@ -508,6 +508,7 @@ module Solargraph
         # @todo Stubbing this method while we debug an infinite loop bug in Ruby 3.x
         return same_type_arity_signatures
 
+        # rubocop:disable Lint/UnreachableCode
         # This is an O(n^2) operation, so bail out if n is not small
         return same_type_arity_signatures if same_type_arity_signatures.length > 10
 
@@ -534,6 +535,7 @@ module Solargraph
             end
           end
         end
+        # rubocop:enable Lint/UnreachableCode
       end
 
       # @param name [String]

data/lib/solargraph/pin/parameter.rb

@@ -31,7 +31,9 @@ module Solargraph
       end
 
       def combine_with other, attrs = {}
-        # Parameters can be combined with local variables
+        # Parameters can only be combined with local variables in the same closure
+        return self unless other.closure == closure
+
         new_attrs = if other.is_a?(Parameter)
                       {
                         decl: assert_same(other, :decl),

data/lib/solargraph/pin/search.rb

@@ -41,11 +41,11 @@ module Solargraph
           match = [fuzzy_string_match(pin.path, @query), fuzzy_string_match(pin.name, @query)].max
           Result.new(match, pin) if match > 0.7
         end
-          .compact
-          # @param a [self]
-          # @param b [self]
-          # @sg-ignore https://github.com/castwide/solargraph/pull/1050
-          .sort { |a, b| b.match <=> a.match }
+             .compact
+             # @param a [self]
+             # @param b [self]
+             # @sg-ignore https://github.com/castwide/solargraph/pull/1050
+             .sort { |a, b| b.match <=> a.match }
              .map(&:pin)
       end
 

data/lib/solargraph/rbs_map/conversions.rb

@@ -481,7 +481,7 @@ module Solargraph
         visibility = VISIBILITY_OVERRIDE[override_key]
         simple_override_key = [closure.path, scope]
         visibility ||= VISIBILITY_OVERRIDE[simple_override_key]
-        if closure.path == 'Kernel' && Kernel.private_instance_methods(false).include?(decl.name)
+        if closure.path == 'Kernel' && Kernel.private_method_defined?(decl.name, false)
           visibility ||= :private
         end
         if decl.kind == :singleton_instance

data/lib/solargraph/source/cursor.rb

@@ -115,8 +115,17 @@ module Solargraph
       def recipient
         @recipient ||= begin
           node = recipient_node
-          # @sg-ignore Need to add nil check here
-          node ? Cursor.new(source, Range.from_node(node).ending) : nil
+          if node.nil?
+            nil
+          else
+            rng = Range.from_node(node)
+            if rng
+              Cursor.new(source, rng.ending)
+            else
+              pos = Position.new(position.line, [position.column - 1, 0].max)
+              Cursor.new(source, pos)
+            end
+          end
         end
       end
       alias receiver recipient

data/lib/solargraph/source_map/clip.rb

@@ -54,8 +54,13 @@ module Solargraph
       # @return [Array<Pin::Method>]
       def signify
         return [] unless cursor.argument?
+        return [] if cursor.recipient_node.nil?
         chain = Parser.chain(cursor.recipient_node, cursor.filename)
-        chain.define(api_map, context_pin, locals).select { |pin| pin.is_a?(Pin::Method) }
+        name_pin = context_pin
+        if name_pin.nil?
+          name_pin = Pin::ProxyType.anonymous(ComplexType.try_parse('::Object'))
+        end
+        chain.define(api_map, name_pin, locals).select { |pin| pin.is_a?(Pin::Method) }
       end
 
       # @return [ComplexType]

data/lib/solargraph/type_checker.rb

@@ -283,7 +283,7 @@ module Solargraph
 
     # @return [Array<Pin::BaseVariable>]
     def all_variables
-      source_map.pins_by_class(Pin::BaseVariable) + source_map.locals.select { |pin| pin.is_a?(Pin::LocalVariable) }
+      source_map.pins_by_class(Pin::BaseVariable) + source_map.locals.grep(Pin::LocalVariable)
     end
 
     # @return [Array<Problem>]
@@ -773,9 +773,9 @@ module Solargraph
         return [] if parameters.any?(&:rest?)
         opt = optional_param_count(parameters)
         return [] if unchecked.length <= req + opt
-        if req + add_params + 1 == unchecked.length && any_splatted_call?(unchecked.map(&:node)) && (parameters.map(&:decl) & %i[
-          kwarg kwoptarg kwrestarg
-        ]).any?
+        if req + add_params + 1 == unchecked.length && any_splatted_call?(unchecked.map(&:node)) && parameters.map(&:decl).intersect?(%i[
+                                                                                                                                        kwarg kwoptarg kwrestarg
+                                                                                                                                      ])
           return []
         end
         return [] if arguments.length - req == parameters.select { |p| %i[optarg kwoptarg].include?(p.decl) }.length

data/lib/solargraph/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Solargraph
-  VERSION = ENV.fetch('SOLARGRAPH_FORCE_VERSION', '0.59.0')
+  VERSION = ENV.fetch('SOLARGRAPH_FORCE_VERSION', '0.59.1')
 end

data/lib/solargraph/yard_map/mapper/to_method.rb

@@ -32,7 +32,7 @@ module Solargraph
           # @sg-ignore Need to add nil check here
           final_visibility ||= VISIBILITY_OVERRIDE[[closure.path, final_scope]]
           # @sg-ignore Need to add nil check here
-          if closure.path == 'Kernel' && Kernel.private_instance_methods(false).include?(name.to_sym)
+          if closure.path == 'Kernel' && Kernel.private_method_defined?(name.to_sym, false)
             final_visibility ||= :private
           end
           final_visibility ||= visibility

data/lib/solargraph.rb

@@ -113,13 +113,13 @@ module Solargraph
   # @yieldreturn [generic<T>]
   # @sg-ignore dynamic call, but both functions behave the same
   # @return [generic<T>]
-  def self.with_clean_env &block
+  def self.with_clean_env(&)
     meth = if Bundler.respond_to?(:with_original_env)
              :with_original_env
            else
              :with_clean_env
            end
-    Bundler.send meth, &block
+    Bundler.send(meth, &)
   end
 end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: solargraph
 version: !ruby/object:Gem::Version
-  version: 0.59.0
+  version: 0.59.1
 platform: ruby
 authors:
 - Fred Snyder