solargraph 0.60.2 → 0.60.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6827dc4bfa0ff6effa9c70ae5dc13bae988d29450b12bbfaca306bd4067f02ee
-  data.tar.gz: a0301099ab04a1e2701971b819a51248abab41d49f03c83f724b1b1ec7d6b519
+  metadata.gz: 0a62c1ebc82583e5c0ee905b75e3f065a1c6185c8268e7b529115fe445afb1a6
+  data.tar.gz: 8b4cc8722f4eb6b3aecb58aaec22d2db54c49a3b2f6477bc7019331de86fbfc7
 SHA512:
-  metadata.gz: 6973d2d9b0230a817e109553e92b9234830feb98429f46c0e1ad882f1f0a63574a9f38fc77d15303f8dac5f57e99815df0e501a798d37060d0753f60dc4d8e7b
-  data.tar.gz: 42a08cb0653d48efffe32ab4c8dd01a7bee94bba8c8e55e8fc5fca953b382935415da7260e862808ae07e9bf61f504e95fdaf5e3aa165ae0fd2e2a919c59db87
+  metadata.gz: 8882c0dffd4a6ac9c4d25c53fdb1789840951fa00860120a25237353c9aa4b2c3454bf04cd94921e56f52871a97978f3ea5b4ed38fba34841d8395eb1223a650
+  data.tar.gz: 5ec51b9ab0cb3d3f445e3282c0c132641a7c9bf52643598a4476ddc5eb23d5527442f0bd434f772b9fcc94a437a956b38607f13d9dc74752df69fae75017963b

data/CHANGELOG.md

@@ -1,3 +1,16 @@
+## 0.60.3 - August 5, 2026
+- Pin rdoc to ~> 7.0 (#1216)
+- (tag: v0.60.2) Release 0.60.2 (rdoc fix)
+- Fix stale Hash::_Key expectations from upstream RBS core drift (#1224)
+- Bump overcommit to ~> 0.71.0 (#1221)
+- Resolve remote constants (#1234)
+- Fix exponential blowup in Pin::Method#combine_same_type_arity_signatures (#1238)
+- Respect #- yard comment-block separator (#1218)
+- Typecheck attribute return tags against their backing ivar's type (#1219)
+- Fix recursive-mutex deadlock in Library#sync_catalog (#1220)
+- Fix Gemspecs#in_this_bundle? crash when no Gemfile is discoverable (#1225)
+- Remove duplicate dead methods in RbsMap::Conversions (#1253)
+
 ## 0.60.2 - June 27, 2026
 - Extraneous debug output (#1214)
 - Pin rdoc to ~> 7.0 (#1216)

data/lib/solargraph/api_map/constants.rb

@@ -155,7 +155,7 @@ module Solargraph
             mixin = resolve(ref.name, ref.reference_gates)
             next unless mixin
 
-            resolved = simple_resolve(name, mixin, internal)
+            resolved = resolve(name, mixin)
             return [resolved, gates[(idx + 1)..]] if resolved
           end
         end

data/lib/solargraph/api_map.rb

@@ -403,11 +403,10 @@ module Solargraph
     # @param candidates [Array<Pin::BaseVariable>]
     # @param name [String]
     # @param closure [Pin::Closure]
-    # @param location [Location]
+    # @param location [Location, nil]
     #
     # @return [Pin::BaseVariable, nil]
     def var_at_location candidates, name, closure, location
-      # @todo Location can be nil if clips have trouble finding node recipients
       return unless location
 
       with_correct_name = candidates.select { |pin| pin.name == name }

data/lib/solargraph/library.rb

@@ -605,8 +605,12 @@ module Solargraph
         queued_gemspec_cache.push(spec)
         return if pending - queued_gemspec_cache.length < 1
 
-        catalog
-        sync_catalog
+        # Try the next cacheable gemspec. This method is always called
+        # from inside sync_catalog's mutex (either directly or via this
+        # same recursive call), so recursing through sync_catalog here
+        # would try to re-lock a mutex this thread already holds and
+        # deadlock (https://github.com/castwide/solargraph/issues/1111).
+        cache_next_gemspec
       else
         logger.info "Caching #{spec.name} #{spec.version}"
         Thread.new do

data/lib/solargraph/pin/method.rb

@@ -509,11 +509,6 @@ module Solargraph
       #
       # @return [Array<Pin::Signature>]
       def combine_same_type_arity_signatures same_type_arity_signatures
-        # @todo Stubbing this method while we debug an infinite loop bug in Ruby 3.x.
-        #   The body below is intentionally preserved for when the stub is removed.
-        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
 
@@ -521,7 +516,9 @@ module Solargraph
         # @param new_signature [Pin::Signature]
         same_type_arity_signatures.reduce([]) do |old_signatures, new_signature|
           next old_signatures + [new_signature] if old_signatures.empty?
-          old_signatures.flat_map do |old_signature|
+
+          merged = false
+          combined = old_signatures.map do |old_signature|
             potential_new_signature = old_signature.combine_with(new_signature)
 
             if potential_new_signature.type_arity == old_signature.type_arity
@@ -534,13 +531,14 @@ module Solargraph
               # based on types, not just arity, allowing for type
               # information describing how methods behave based on
               # their input types)
-              old_signatures - [old_signature] + [potential_new_signature]
+              merged = true
+              potential_new_signature
             else
-              old_signatures + [new_signature]
+              old_signature
             end
           end
+          merged ? combined : old_signatures + [new_signature]
         end
-        # rubocop:enable Lint/UnreachableCode
       end
 
       # @param name [String]

data/lib/solargraph/rbs_map/conversions.rb

@@ -159,27 +159,6 @@ module Solargraph
         RBS_TO_CLASS.fetch(ns, ns)
       end
 
-      # @param type_name [RBS::TypeName]
-      # @param type_args [Enumerable<RBS::Types::Bases::Base>]
-      # @return [ComplexType::UniqueType]
-      def build_type type_name, type_args = []
-        # we use .absolute? below to tell the type object what to
-        # expect
-        rbs_name = type_name.relative!.to_s
-        base = RBS_TO_CLASS.fetch(rbs_name, rbs_name)
-
-        params = type_args.map { |a| RbsTranslator.to_complex_type(a) }
-        # @todo Tuples are in flux
-        # tuples have their own class and are handled in other_type_to_type
-        if base == 'Hash' && params.length == 2
-          ComplexType::UniqueType.new(base, [params.first], [params.last], rooted: type_name.absolute?,
-                                                                           parameters_type: :hash)
-        else
-          ComplexType::UniqueType.new(base, [], params.reject(&:undefined?), rooted: type_name.absolute?,
-                                                                             parameters_type: :list)
-        end
-      end
-
       # @param decl [RBS::AST::Declarations::Module::Self]
       # @param closure [Pin::Namespace]
       # @return [void]
@@ -561,7 +540,8 @@ module Solargraph
       def method_def_to_sigs decl, pin
         # rubocop:disable Style/SafeNavigationChainLength
         implicit_nil = decl.overloads.first&.annotations&.map(&:string)&.include?('implicitly-returns-nil') || false
-        # rubocop:enable Style/SafeNavigationChainLength        # @param overload [RBS::AST::Members::MethodDefinition::Overload]
+        # rubocop:enable Style/SafeNavigationChainLength
+        # @param overload [RBS::AST::Members::MethodDefinition::Overload]
         decl.overloads.map do |overload|
           type_location = location_decl_to_pin_location(overload.method_type.location)
           generics = overload.method_type.type_params.map(&:name).map(&:to_s)
@@ -587,84 +567,6 @@ module Solargraph
         Location.new(location.name.to_s, range)
       end
 
-      # @param type [RBS::MethodType, RBS::Types::Block]
-      # @param pin [Pin::Method]
-      # @param implicit_nil [Boolean]
-      # @return [Array(Array<Pin::Parameter>, ComplexType)]
-      def parts_of_function type, pin, implicit_nil
-        type_location = pin.type_location
-        if defined?(RBS::Types::UntypedFunction) && type.type.is_a?(RBS::Types::UntypedFunction)
-          return [
-            [Solargraph::Pin::Parameter.new(decl: :restarg, name: 'arg', closure: pin, source: :rbs,
-                                            type_location: type_location)],
-            method_type_to_type(type, implicit_nil)
-          ]
-        end
-
-        parameters = []
-        arg_num = -1
-        type.type.required_positionals.each do |param|
-          # @sg-ignore Unresolved call to name
-          name = param.name ? param.name.to_s : "arg_#{arg_num += 1}"
-          parameters.push Solargraph::Pin::Parameter.new(decl: :arg, name: name, closure: pin,
-                                                         # @sg-ignore RBS generic type understanding issue
-                                                         return_type: other_type_to_type(param.type),
-                                                         source: :rbs, type_location: type_location)
-        end
-        type.type.optional_positionals.each do |param|
-          # @sg-ignore Unresolved call to name
-          name = param.name ? param.name.to_s : "arg_#{arg_num += 1}"
-          parameters.push Solargraph::Pin::Parameter.new(decl: :optarg, name: name, closure: pin,
-                                                         # @sg-ignore RBS generic type understanding issue
-                                                         return_type: other_type_to_type(param.type),
-                                                         type_location: type_location,
-                                                         source: :rbs)
-        end
-        if type.type.rest_positionals
-          name = type.type.rest_positionals.name ? type.type.rest_positionals.name.to_s : "arg_#{arg_num += 1}"
-          inner_rest_positional_type = other_type_to_type(type.type.rest_positionals.type)
-          rest_positional_type = ComplexType::UniqueType.new('Array',
-                                                             [],
-                                                             [inner_rest_positional_type],
-                                                             rooted: true, parameters_type: :list)
-          parameters.push Solargraph::Pin::Parameter.new(decl: :restarg, name: name, closure: pin,
-                                                         source: :rbs, type_location: type_location,
-                                                         return_type: rest_positional_type)
-        end
-        type.type.trailing_positionals.each do |param|
-          # @sg-ignore Unresolved call to name
-          name = param.name ? param.name.to_s : "arg_#{arg_num += 1}"
-          parameters.push Solargraph::Pin::Parameter.new(decl: :arg, name: name, closure: pin, source: :rbs,
-                                                         type_location: type_location)
-        end
-        type.type.required_keywords.each do |orig, param|
-          # @sg-ignore Unresolved call to to_s
-          name = orig ? orig.to_s : "arg_#{arg_num += 1}"
-          parameters.push Solargraph::Pin::Parameter.new(decl: :kwarg, name: name, closure: pin,
-                                                         # @sg-ignore RBS generic type understanding issue
-                                                         return_type: other_type_to_type(param.type),
-                                                         source: :rbs, type_location: type_location)
-        end
-        type.type.optional_keywords.each do |orig, param|
-          # @sg-ignore Unresolved call to to_s
-          name = orig ? orig.to_s : "arg_#{arg_num += 1}"
-          parameters.push Solargraph::Pin::Parameter.new(decl: :kwoptarg, name: name, closure: pin,
-                                                         # @sg-ignore RBS generic type understanding issue
-                                                         return_type: other_type_to_type(param.type),
-                                                         type_location: type_location,
-                                                         source: :rbs)
-        end
-        if type.type.rest_keywords
-          name = type.type.rest_keywords.name ? type.type.rest_keywords.name.to_s : "arg_#{arg_num += 1}"
-          parameters.push Solargraph::Pin::Parameter.new(decl: :kwrestarg,
-                                                         name: type.type.rest_keywords.name.to_s, closure: pin,
-                                                         source: :rbs, type_location: type_location)
-        end
-
-        return_type = method_type_to_type(type, implicit_nil)
-        [parameters, return_type]
-      end
-
       # @param type [RBS::MethodType,RBS::Types::Block]
       # @param pin [Pin::Method]
       # @param implicit_nil [Boolean]

data/lib/solargraph/source/chain/call.rb

@@ -14,7 +14,7 @@ module Solargraph
         # @return [String]
         attr_reader :word
 
-        # @return [Location]
+        # @return [Location, nil]
         attr_reader :location
 
         # @return [::Array<Chain>]

data/lib/solargraph/source/chain/instance_variable.rb

@@ -13,10 +13,6 @@ module Solargraph
           @location = location
         end
 
-        # @sg-ignore Declared return type
-        #   ::Array<::Solargraph::Pin::Base> does not match inferred
-        #   type ::Array<::Solargraph::Pin::BaseVariable, ::NilClass>
-        #   for Solargraph::Source::Chain::InstanceVariable#resolve
         def resolve api_map, name_pin, locals
           ivars = api_map.get_instance_variable_pins(name_pin.context.namespace, name_pin.context.scope).select do |p|
             p.name == word
@@ -27,8 +23,7 @@ module Solargraph
 
         private
 
-        # @todo: Missed nil violation
-        # @return [Location]
+        # @return [Location, nil]
         attr_reader :location
       end
     end

data/lib/solargraph/source.rb

@@ -209,7 +209,7 @@ module Solargraph
       stringified_comments[rng.start.line] ||= begin
         # @sg-ignore Need to add nil check here
         buff = associated_comments[rng.start.line]
-        buff ? stringify_comment_array(buff) : nil
+        stringify_comment_array(buff)
       end
     end
 
@@ -249,20 +249,20 @@ module Solargraph
 
     # Get a hash of comments grouped by the line numbers of the associated code.
     #
-    # @return [Hash{Integer => String, nil}]
+    # @return [Hash{Integer => Array<String>}]
     def associated_comments
       @associated_comments ||= begin
         # @type [Hash{Integer => String}]
         result = {}
-        buffer = String.new('')
+        buffer = []
         # @type [Integer, nil]
         last = nil
         comments.each_pair do |num, snip|
           if !last || num == last + 1
-            buffer.concat "#{snip.text}\n"
+            buffer.push "#{snip.text}\n"
           else
             result[first_not_empty_from(last + 1)] = buffer.clone
-            buffer.replace "#{snip.text}\n"
+            buffer.replace ["#{snip.text}\n"]
           end
           last = num
         end
@@ -305,27 +305,31 @@ module Solargraph
 
     # Get a string representation of an array of comments.
     #
-    # @param comments [String]
+    # @param comments [Array<String>, nil]
     # @return [String]
     def stringify_comment_array comments
-      ctxt = String.new('')
+      ctxt = []
       started = false
       skip = nil
-      comments.lines.each do |l|
+      comments&.each do |l|
+        if l =~ /^#-\R/
+          ctxt.clear
+          next
+        end
         # Trim the comment and minimum leading whitespace
         p = l.force_encoding('UTF-8').encode('UTF-8', invalid: :replace, replace: '?').gsub(/^#+/, '')
         if p.strip.empty?
           next unless started
-          ctxt.concat p
+          ctxt.push p
         else
           here = p.index(/[^ \t]/)
           # @sg-ignore flow sensitive typing should be able to handle redefinition
           skip = here if skip.nil? || here < skip
-          ctxt.concat p[skip..]
+          ctxt.push p[skip..]
         end
         started = true
       end
-      ctxt
+      ctxt.join('')
     end
 
     # A hash of line numbers and their associated comments.

data/lib/solargraph/source_map/mapper.rb

@@ -145,8 +145,8 @@ module Solargraph
                       )
                     end
           # @sg-ignore Need to add nil check here
-          com_pos = Position.new(line + 1 - comments.lines.length, 0)
-          process_comment(src_pos, com_pos, comments)
+          com_pos = Position.new(line + 1 - comments.length, 0)
+          process_comment(src_pos, com_pos, comments.join(''))
         end
       rescue StandardError => e
         raise e.class, "Error processing comment directives in #{@filename}: #{e.message}"

data/lib/solargraph/type_checker.rb

@@ -162,10 +162,19 @@ module Solargraph
           result.push Problem.new(pin.location, "Untyped method #{pin.path} could not be inferred")
         end
       elsif rules.validate_tags?
-        unless pin.node.nil? || declared.void? || virtual_pin?(pin) || abstract?(pin)
+        # Attribute pins never have a node (attr_reader/attr_writer/attr_accessor are
+        # synthesized, not parsed method bodies), but their inferred type is still
+        # meaningful: #probe walks the backing ivar's assignments via infer_from_iv.
+        # Without this carve-out, a manually-written @return tag on an attribute is
+        # never cross-checked against how the ivar is actually assigned (e.g. a nilable
+        # default in the constructor), so a bad tag silently passes at every level.
+        unless (pin.node.nil? && !pin.attribute?) || declared.void? || virtual_pin?(pin) || abstract?(pin)
           inferred = pin.probe(api_map).self_to_type(pin.full_context)
           if inferred.undefined?
-            unless rules.ignore_all_undefined? || external?(pin)
+            # An attribute with no locally-discoverable ivar assignment (set via a
+            # mixin, metaprogramming, etc.) isn't a tag/inference mismatch - just
+            # unproven. Only methods with an actual body get flagged for this.
+            unless rules.ignore_all_undefined? || external?(pin) || pin.attribute?
               result.push Problem.new(pin.location, "#{pin.path} return type could not be inferred", pin: pin)
             end
           else
@@ -848,7 +857,7 @@ module Solargraph
     def all_sg_ignore_lines
       source.associated_comments.select do |_line, text|
         # @sg-ignore Need to add nil check here
-        text.include?('@sg-ignore')
+        text.any? { |t| t.include?('@sg-ignore') }
       end.keys.to_set
     end
 

data/lib/solargraph/version.rb

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

data/lib/solargraph/workspace/gemspecs.rb

@@ -220,6 +220,12 @@ module Solargraph
       # @sg-ignore need boolish support for ? methods
       def in_this_bundle?
         Bundler.definition&.lockfile&.to_s&.start_with?(directory)
+      rescue Bundler::GemfileNotFound
+        # Solargraph itself isn't running under a discoverable Gemfile
+        # (e.g. installed and invoked as a standalone gem), so it can't
+        # be "this bundle" - fall back to treating the workspace as an
+        # external bundle.
+        false
       end
 
       # @return [Array<Gem::Specification, Bundler::LazySpecification, Bundler::StubSpecification>]

data/solargraph.gemspec

@@ -65,7 +65,7 @@ Gem::Specification.new do |s|
   #
   # even more specific on RuboCop itself, which is written into _todo
   # file.
-  s.add_development_dependency 'overcommit', '~> 0.68.0'
+  s.add_development_dependency 'overcommit', '~> 0.71.0'
   s.add_development_dependency 'rubocop', '~> 1.80.0.0'
   s.add_development_dependency 'rubocop-rake', '~> 0.7.1'
   s.add_development_dependency 'rubocop-rspec', '~> 3.6.0'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: solargraph
 version: !ruby/object:Gem::Version
-  version: 0.60.2
+  version: 0.60.3
 platform: ruby
 authors:
 - Fred Snyder
@@ -419,14 +419,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.68.0
+        version: 0.71.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.68.0
+        version: 0.71.0
 - !ruby/object:Gem::Dependency
   name: rubocop
   requirement: !ruby/object:Gem::Requirement