solargraph 0.60.2 → 0.60.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6827dc4bfa0ff6effa9c70ae5dc13bae988d29450b12bbfaca306bd4067f02ee
-  data.tar.gz: a0301099ab04a1e2701971b819a51248abab41d49f03c83f724b1b1ec7d6b519
+  metadata.gz: 7c7397d5a9bbee07b12baa9372ce14f61216e5a310aa0f68605acabf8a9430e2
+  data.tar.gz: aeecf5c5d1ea7b1040fd3ae4bd9d1bff1685e468bd92b30dedfdd8ded2f1cd04
 SHA512:
-  metadata.gz: 6973d2d9b0230a817e109553e92b9234830feb98429f46c0e1ad882f1f0a63574a9f38fc77d15303f8dac5f57e99815df0e501a798d37060d0753f60dc4d8e7b
-  data.tar.gz: 42a08cb0653d48efffe32ab4c8dd01a7bee94bba8c8e55e8fc5fca953b382935415da7260e862808ae07e9bf61f504e95fdaf5e3aa165ae0fd2e2a919c59db87
+  metadata.gz: f4abae37c4fc8b57efe4a7b3550a2edbfc64455e8852f81660220f4a67facf101eafd058805b58cf0be6f9d5b9d16317cd21f6cd3b47f0c666c48418ee0d54c2
+  data.tar.gz: e14586769600dd63e2a96b8bcb4a5e4aa9bb045948e87e8c06b6606e711fed6816347051505eb756df55fed375a0419431dd02a44c2082d6d1ec0e2b13c6564f

data/.github/workflows/plugins.yml

@@ -129,12 +129,8 @@ jobs:
     - name: clone https://github.com/lekemula/solargraph-rspec/
       run: |
        cd ..
-       # git clone https://github.com/lekemula/solargraph-rspec.git
-
-       # pending https://github.com/lekemula/solargraph-rspec/pull/31
-       git clone https://github.com/apiology/solargraph-rspec.git
+       git clone https://github.com/lekemula/solargraph-rspec.git
        cd solargraph-rspec
-       git checkout test_solargraph_prereleases
     - name: Set up Ruby
       uses: ruby/setup-ruby@v1
       with:

data/CHANGELOG.md

@@ -1,3 +1,26 @@
+## 0.60.4 - August 30, 2026
+- Fix @yieldparam type lost on multi-overload block-form methods (#1289) (#1290)
+- Read inline RBS superclass params only on the class line (#1301)
+- Stop recording YARD's implicit Object superclass (#1315)
+- Improve overload resolution and macro handling in Chain::Call (#1247)
+- Fix Chain#nullable? leaking nil from earlier &. into later calls (#1271)
+- Handle YARD bug with open singleton classes (#1279)
+- Fix duck_types_match? to check the inferred type's own duck interface (#1295)
+- Use the original repo (run_solargraph_rspec_specs job) (#1291)
+
+## 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/complex_type.rb

@@ -227,7 +227,7 @@ module Solargraph
       expected = expected.downcast_to_literal_if_possible
       inferred = downcast_to_literal_if_possible
 
-      return duck_types_match?(api_map, expected, inferred) if expected.duck_type?
+      return duck_types_match?(api_map, expected, inferred, rules) if expected.duck_type?
 
       if rules.include? :allow_any_match
         inferred.any? do |inf|
@@ -245,18 +245,31 @@ module Solargraph
     # @param api_map [ApiMap]
     # @param expected [ComplexType, UniqueType]
     # @param inferred [ComplexType, UniqueType]
+    # @param rules [Array<Symbol>]
     # @return [Boolean]
-    def duck_types_match? api_map, expected, inferred
+    def duck_types_match? api_map, expected, inferred, rules = []
       raise ArgumentError, 'Expected type must be duck type' unless expected.duck_type?
+      allow_any_match = rules.include?(:allow_any_match)
       expected.each do |exp|
         next unless exp.duck_type?
-        quack = exp.to_s[1..]
-        # @sg-ignore Need to add nil check here
-        return false if api_map.get_method_stack(inferred.namespace, quack, scope: inferred.scope).empty?
+        quack = exp.to_s[1..] || ''
+        matched = allow_any_match ? inferred.any? { |inf| duck_type_provides?(api_map, inf, quack) } : inferred.all? { |inf| duck_type_provides?(api_map, inf, quack) }
+        return false unless matched
       end
       true
     end
 
+    # @param api_map [ApiMap]
+    # @param inf [UniqueType]
+    # @param quack [String]
+    # @return [Boolean]
+    def duck_type_provides? api_map, inf, quack
+      return true if inf.duck_type? && inf.to_s[1..] == quack
+
+      !api_map.get_method_stack(inf.namespace, quack, scope: inf.scope).empty?
+    end
+    private :duck_type_provides?
+
     # @return [String]
     def rooted_tags
       map(&:rooted_tag).join(', ')

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/parser/parser_gem/node_processors/namespace_node.rb

@@ -27,7 +27,6 @@ module Solargraph
               source: :parser
             )
             pins.push nspin
-            Solargraph.logger.warn "Superclass: #{superclass_name}" if superclass_name&.start_with?('Array')
             if superclass_name
               pins.push Pin::Reference::Superclass.new(
                 location: loc,
@@ -41,12 +40,22 @@ module Solargraph
 
           private
 
-          # @param comments [String]
+          # Type arguments for a generic superclass in inline RBS syntax, e.g.,
+          # `class Foo < Array #[String]`. Only recognized where RBS defines
+          # it: directly after the superclass, on the same line, with no space
+          # between `#` and `[`. Anything else is an ordinary comment.
+          #
           # @return [String, nil]
           def parameters_from_inline_rbs
-            source = region.source.code_for(node)
-            match = source.match(/[^\n]*?#\s?+\[([^\]]*)/)
-            return unless match && match[1]
+            superclass = node.children[1]
+            return unless superclass
+
+            source = region.source.code
+            pos = get_node_end_position(superclass)
+            offset = Position.line_char_to_offset(source, pos.line, pos.character)
+            eol = source.index("\n", offset) || source.length
+            match = source[offset...eol].to_s.match(/\A\s*#\[([^\]]*)\]/)
+            return unless match
 
             code = match[1].strip
             return if code.empty?

data/lib/solargraph/pin/method.rb

@@ -148,12 +148,13 @@ module Solargraph
 
       # @param parameters [::Array<Parameter>]
       # @param return_type [ComplexType, nil]
+      # @param tag_docstring [YARD::Docstring] source of @yieldparam/@yieldreturn tags; pass an @overload tag's own docstring here
       # @return [Signature]
-      def generate_signature parameters, return_type
+      def generate_signature parameters, return_type, tag_docstring = docstring
         # @type [Pin::Signature, nil]
         block = nil
-        yieldparam_tags = docstring.tags(:yieldparam)
-        yieldreturn_tags = docstring.tags(:yieldreturn)
+        yieldparam_tags = tag_docstring.tags(:yieldparam)
+        yieldreturn_tags = tag_docstring.tags(:yieldreturn)
         generics = docstring.tags(:generic).map(&:name)
         needs_block_param_signature =
           parameters.last&.block? || !yieldreturn_tags.empty? || !yieldparam_tags.empty?
@@ -509,11 +510,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 +517,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 +532,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]
@@ -749,7 +748,9 @@ module Solargraph
         top_type = generate_complex_type
         result = []
         result.push generate_signature(parameters, top_type) if top_type.defined?
-        result.concat(overloads.map { |meth| generate_signature(meth.parameters, meth.return_type) }) unless overloads.empty?
+        # @param meth [Pin::Signature]
+        # @param tag [YARD::Tags::OverloadTag]
+        result.concat(overloads.zip(docstring.tags(:overload).select(&:parameters)).map { |meth, tag| generate_signature(meth.parameters, meth.return_type, tag.docstring) }) unless overloads.empty?
         result.push generate_signature(parameters, @return_type || ComplexType::UNDEFINED) if result.empty?
         result
       end

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>]
@@ -71,6 +71,95 @@ module Solargraph
 
         private
 
+        # Checks whether a single overload signature matches the call's
+        # arguments/block and, if so, resolves its return type. Threaded
+        # through the caller's accumulator so behavior matches the
+        # original inline loop: if the overload doesn't match, the
+        # incoming type/signature are returned unchanged.
+        #
+        # @param overload [Pin::Signature]
+        # @param pin [Pin::Method]
+        # @param api_map [ApiMap]
+        # @param name_pin [Pin::Base]
+        # @param locals [::Array<Solargraph::Pin::LocalVariable, Solargraph::Pin::Parameter>]
+        # @param type [ComplexType]
+        # @param new_signature_pin [Pin::Signature, nil]
+        # @return [::Array(ComplexType, Pin::Signature)]
+        def match_overload_type overload, pin, api_map, name_pin, locals, type, new_signature_pin
+          return [type, new_signature_pin] unless overload.arity_matches?(arguments, with_block?)
+
+          match = true
+          atypes = []
+          arguments.each_with_index do |arg, idx|
+            param = overload.parameters[idx]
+            if param.nil?
+              match = overload.parameters.any?(&:restarg?)
+              break
+            end
+            arg_name_pin = Pin::ProxyType.anonymous(name_pin.context,
+                                                    closure: name_pin.closure,
+                                                    gates: name_pin.gates,
+                                                    source: :chain)
+            atype = atypes[idx] ||= arg.infer(api_map, arg_name_pin, locals)
+            # @sg-ignore flow sensitive typing should handle is_a? and next
+            unless param.compatible_arg?(atype, api_map) || param.restarg?
+              match = false
+              break
+            end
+          end
+          return [type, new_signature_pin] unless match
+
+          if overload.block && with_block?
+            block_atypes = overload.block.parameters.map(&:return_type)
+            # @todo Need to add nil check here
+            # @sg-ignore Need to add nil check here
+            blocktype = if block.links.map(&:class) == [BlockSymbol]
+                          # like the bar in foo(&:bar)
+                          block_symbol_call_type(api_map, name_pin.context, block_atypes, locals)
+                        else
+                          block_call_type(api_map, name_pin, locals)
+                        end
+          end
+          new_signature_pin = overload.resolve_generics_from_context_until_complete(overload.generics, atypes, nil, nil,
+                                                                                    blocktype)
+          # @todo It shouldn't be necessary to choose either generics or macros
+          # @sg-ignore Need to add nil check here
+          new_return_type = if new_signature_pin.return_type.defined?
+                              # @sg-ignore Need to add nil check here
+                              new_signature_pin.return_type
+                            else
+                              # @sg-ignore Need to add nil check here
+                              named_types = pin.parameter_names.zip(arguments.map { |arg| ComplexType.try_parse(simple_convert(arg.node).to_s) }).to_h
+                              pin.typify(api_map).expand(named_types)
+                            end
+          self_type = if head?
+                        # If we're at the head of the chain, we called a
+                        # method somewhere that marked itself as returning
+                        # self.  Given we didn't invoke this on an object,
+                        # this must be a method in this same class - so we
+                        # use our own self type
+                        name_pin.context
+                      else
+                        # if we're past the head in the chain, whatever the
+                        # type of the lhs side is what 'self' will be in its
+                        # declaration - we can't just use the type of the
+                        # method pin, as this might be a subclass of the
+                        # place where the method is defined
+                        name_pin.binder
+                      end
+          # This same logic applies to the YARD work done by
+          # 'with_params()'.
+          #
+          # qualify(), however, happens in the namespace where
+          # the docs were written - from the method pin.
+          # @todo Need to add nil check here
+          if new_return_type.defined?
+            type = with_params(new_return_type.self_to_type(self_type), self_type).qualify(api_map, *pin.gates)
+          end
+          type ||= ComplexType::UNDEFINED
+          [type, new_signature_pin]
+        end
+
         # @param pins [::Enumerable<Pin::Base>]
         # @param api_map [ApiMap]
         # @param name_pin [Pin::Base]
@@ -96,76 +185,20 @@ module Solargraph
             # @sg-ignore flow sensitive typing should handle is_a? and next
             # @param ol [Pin::Signature]
             sorted_overloads.each do |ol|
-              next unless ol.arity_matches?(arguments, with_block?)
-              match = true
-
-              atypes = []
-              arguments.each_with_index do |arg, idx|
-                param = ol.parameters[idx]
-                if param.nil?
-                  match = ol.parameters.any?(&:restarg?)
-                  break
-                end
-                arg_name_pin = Pin::ProxyType.anonymous(name_pin.context,
-                                                        closure: name_pin.closure,
-                                                        gates: name_pin.gates,
-                                                        source: :chain)
-                atype = atypes[idx] ||= arg.infer(api_map, arg_name_pin, locals)
-                unless param.compatible_arg?(atype, api_map) || param.restarg?
-                  match = false
-                  break
-                end
-              end
-              if match
-                if ol.block && with_block?
-                  block_atypes = ol.block.parameters.map(&:return_type)
-                  # @todo Need to add nil check here
-                  blocktype = if block.links.map(&:class) == [BlockSymbol]
-                                # like the bar in foo(&:bar)
-                                block_symbol_call_type(api_map, name_pin.context, block_atypes, locals)
-                              else
-                                block_call_type(api_map, name_pin, locals)
-                              end
-                end
-                new_signature_pin = ol.resolve_generics_from_context_until_complete(ol.generics, atypes, nil, nil,
-                                                                                    blocktype)
-                # @todo It shouldn't be necessary to choose either generics or macros
-                new_return_type = if new_signature_pin.return_type.defined?
-                  new_signature_pin.return_type
-                else
-                  named_types = p.parameter_names.zip(arguments.map { |arg| ComplexType.try_parse(simple_convert(arg.node).to_s) }).to_h
-                  p.typify(api_map).expand(named_types)
-                end
-                self_type = if head?
-                              # If we're at the head of the chain, we called a
-                              # method somewhere that marked itself as returning
-                              # self.  Given we didn't invoke this on an object,
-                              # this must be a method in this same class - so we
-                              # use our own self type
-                              name_pin.context
-                            else
-                              # if we're past the head in the chain, whatever the
-                              # type of the lhs side is what 'self' will be in its
-                              # declaration - we can't just use the type of the
-                              # method pin, as this might be a subclass of the
-                              # place where the method is defined
-                              name_pin.binder
-                            end
-                # This same logic applies to the YARD work done by
-                # 'with_params()'.
-                #
-                # qualify(), however, happens in the namespace where
-                # the docs were written - from the method pin.
-                # @todo Need to add nil check here
-                if new_return_type.defined?
-                  type = with_params(new_return_type.self_to_type(self_type), self_type).qualify(api_map, *p.gates)
-                end
-                type ||= ComplexType::UNDEFINED
-              end
+              type, new_signature_pin = match_overload_type(ol, p, api_map, name_pin, locals, type, new_signature_pin)
               break if type.defined?
             end
             p = p.with_single_signature(new_signature_pin) unless new_signature_pin.nil?
             next p.proxy(type) if type.defined?
+            if !p.macros.empty?
+              result = process_macro(p, api_map, name_pin.context, locals)
+              # @sg-ignore flow sensitive typing should be able to handle redefinition
+              next result unless result.return_type.undefined?
+            elsif !p.directives.empty?
+              result = process_directive(p, api_map, name_pin.context, locals)
+              # @sg-ignore flow sensitive typing should be able to handle redefinition
+              next result unless result.return_type.undefined?
+            end
             p
           end
           logger.debug do
@@ -186,6 +219,71 @@ module Solargraph
           end
         end
 
+        # @param pin [Pin::Base]
+        # @param api_map [ApiMap]
+        # @param context [ComplexType, ComplexType::UniqueType]
+        # @param locals [::Array<Solargraph::Pin::LocalVariable, Solargraph::Pin::Parameter>]
+        # @return [Pin::Base]
+        def process_macro pin, api_map, context, locals
+          pin.macros.each do |macro|
+            # @todo 'Wrong argument type for
+            #   Solargraph::Source::Chain::Call#inner_process_macro:
+            #   macro expected YARD::Tags::MacroDirective, received
+            #   generic<Elem>' is because we lose 'rooted' information
+            #   in the 'Chain::Array' class internally, leaving
+            #   ::Array#each shadowed when it shouldn't be.
+            # @sg-ignore macro is Solargraph::YardMap::Macro, wraps a YARD::Tags::MacroDirective
+            result = inner_process_macro(pin, macro, api_map, context, locals)
+            return result unless result.return_type.undefined?
+          end
+          Pin::ProxyType.anonymous(ComplexType::UNDEFINED, source: :chain)
+        end
+
+        # @param pin [Pin::Method]
+        # @param api_map [ApiMap]
+        # @param context [ComplexType, ComplexType::UniqueType]
+        # @param locals [::Array<Solargraph::Pin::LocalVariable, Solargraph::Pin::Parameter>]
+        # @return [Pin::ProxyType]
+        def process_directive pin, api_map, context, locals
+          pin.directives.each do |dir|
+            macro = api_map.named_macro(dir.tag.name)
+            next if macro.nil?
+            # @sg-ignore macro is Solargraph::YardMap::Macro, wraps a YARD::Tags::MacroDirective
+            result = inner_process_macro(pin, macro, api_map, context, locals)
+            return result unless result.return_type.undefined?
+          end
+          Pin::ProxyType.anonymous ComplexType::UNDEFINED, source: :chain
+        end
+
+        # @param pin [Pin::Base]
+        # @param macro [YARD::Tags::MacroDirective]
+        # @param api_map [ApiMap]
+        # @param context [ComplexType, ComplexType::UniqueType]
+        # @param locals [::Array<Pin::LocalVariable, Pin::Parameter>]
+        # @return [Pin::ProxyType]
+        def inner_process_macro pin, macro, api_map, context, locals
+          vals = arguments.map { |c| Pin::ProxyType.anonymous(c.infer(api_map, pin, locals), source: :chain) }
+          txt = macro.tag.text.clone
+          # @sg-ignore Need to add nil check here
+          if txt.empty? && macro.tag.name
+            named = api_map.named_macro(macro.tag.name)
+            txt = named.tag.text.clone if named
+          end
+          i = 1
+          vals.each do |v|
+            # @sg-ignore Need to add nil check here
+            txt.gsub!(/\$#{i}/, v.context.namespace)
+            i += 1
+          end
+          # @sg-ignore Need to add nil check here
+          docstring = Solargraph::Source.parse_docstring(txt).to_docstring
+          tag = docstring.tag(:return)
+          unless tag.nil? || tag.types.nil?
+            return Pin::ProxyType.anonymous(ComplexType.try_parse(*tag.types), source: :chain)
+          end
+          Pin::ProxyType.anonymous(ComplexType::UNDEFINED, source: :chain)
+        end
+
         # @param docstring [YARD::Docstring]
         # @param context [ComplexType]
         # @return [ComplexType, nil]

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/chain.rb

@@ -168,7 +168,7 @@ module Solargraph
           return ComplexType::UNDEFINED
         end
         type = infer_from_definitions(pins, links.last.last_context, api_map, locals)
-        out = maybe_nil(type)
+        out = maybe_nil(type, api_map)
         logger.debug do
           "Chain#infer_uncached(links=#{links.map(&:desc)}, locals=#{locals.map(&:desc)}, " \
             "name_pin=#{name_pin}, name_pin.closure=#{name_pin&.closure&.inspect}, " \
@@ -199,8 +199,38 @@ module Solargraph
         @splat
       end
 
-      def nullable?
-        links.any?(&:nullable?)
+      # Whether this chain's inferred type should have nil added to it
+      # because a `&.` earlier in the chain might have short-circuited
+      # evaluation to nil.
+      #
+      # A `&.` only makes the *immediate* call nil-or-normal-result; a
+      # later, non-safe-navigated call in the same chain is still
+      # invoked on whatever that produced. If receiver is nil at that
+      # point, Ruby calls the method on nil itself instead of skipping
+      # it - so nil only continues to flow through subsequent links
+      # that NilClass defines as returning `self` (e.g., #tap,
+      # #itself). Any other subsequent call resolves to a concrete,
+      # non-nil-including type (e.g. NilClass#== returns Boolean), and
+      # nil no longer needs to be tracked past that point (unless a
+      # later `&.` reintroduces it).
+      #
+      # @param api_map [ApiMap]
+      # @return [Boolean]
+      def nullable? api_map
+        currently_nullable = false
+        links.each do |link|
+          if link.nullable?
+            currently_nullable = true
+            next
+          end
+          next unless currently_nullable
+          next unless link.is_a?(Chain::Call)
+
+          pin = api_map.get_method_stack('NilClass', link.word, scope: :instance).first
+          # @sg-ignore Need to add nil check here
+          currently_nullable = pin.nil? || pin.return_type.tag == 'self'
+        end
+        currently_nullable
       end
 
       include Logging
@@ -286,10 +316,11 @@ module Solargraph
       end
 
       # @param type [ComplexType, ComplexType::UniqueType]
+      # @param api_map [ApiMap]
       # @return [ComplexType, ComplexType::UniqueType]
-      def maybe_nil type
+      def maybe_nil type, api_map
         return type if type.undefined? || type.void? || type.nullable?
-        return type unless nullable?
+        return type unless nullable?(api_map)
         ComplexType.new(type.items + [ComplexType::NIL])
       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.4')
 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/lib/solargraph/yard_map/mapper.rb

@@ -11,7 +11,7 @@ module Solargraph
       # @param spec [Gem::Specification, nil]
       def initialize code_objects, spec = nil
         @code_objects = code_objects
-        @macro_code_objects = code_objects.select { |co| co.is_a?(YARD::CodeObjects::MacroObject) }
+        @macro_code_objects = code_objects.grep(YARD::CodeObjects::MacroObject)
         @spec = spec
         # @type [Array<Solargraph::Pin::Base>]
         @pins = []
@@ -32,13 +32,17 @@ module Solargraph
 
       private
 
+      def core_store
+        @core_store ||= ApiMap::Store.new(RbsMap::CoreMap.new.pins)
+      end
+
       # @param code_object [YARD::CodeObjects::Base]
       # @return [Array<Pin::Base>]
       def generate_pins code_object
         result = []
         case code_object
         when YARD::CodeObjects::NamespaceObject
-          nspin = ToNamespace.make(code_object, @spec, @namespace_pins[code_object.namespace.to_s])
+          nspin = namespace_with_bug_fix(code_object)
           @namespace_pins[code_object.path] = nspin
           result.push nspin
           if code_object.is_a?(YARD::CodeObjects::ClassObject) && !code_object.superclass.nil?
@@ -50,7 +54,16 @@ module Solargraph
                          else
                            code_object.superclass.to_s
                          end
-            result.push Solargraph::Pin::Reference::Superclass.new(name: superclass, closure: nspin, source: :yard_map)
+            # YARD fills in `Object` for every class whose definition it never
+            # saw a superclass clause on - including a bare `class Foo`
+            # reopening, which asserts nothing about ancestry - and keeps no
+            # record of which case it was. A class with no superclass reference
+            # already resolves to Object, so recording this one adds nothing and
+            # can shadow a superclass declared in another source.
+            unless superclass.delete_prefix('::') == 'Object'
+              result.push Solargraph::Pin::Reference::Superclass.new(name: superclass, closure: nspin,
+                                                                     source: :yard_map)
+            end
           end
           # @sg-ignore flow sensitive typing ought to be able to handle 'when ClassName'
           code_object.class_mixins.each do |m|
@@ -72,6 +85,8 @@ module Solargraph
             # @todo Check the visibility of <Class>.new
             result.push ToMethod.make(code_object, 'new', :class, :public, closure, @spec)
             result.push ToMethod.make(code_object, 'initialize', :instance, :private, closure, @spec)
+          elsif closure&.source == :yard_map_hack
+            result.push ToMethod.make(code_object, nil, :instance, nil, closure, @spec)
           else
             result.push ToMethod.make(code_object, nil, nil, nil, closure, @spec)
           end
@@ -97,6 +112,24 @@ module Solargraph
       def macros_for_method_object method_object
         attached_macros_by_method_object[method_object]
       end
+
+      # Handle a bug in YARD where code that opens a constant's singleton class
+      # (e.g., `class << ENV`) creates a pin that incorrectly overrides the
+      # original constant's value.
+      #
+      # @param code_object [YARD::CodeObjects::NamespaceObject]
+      # @return [Pin::Namespace]
+      def namespace_with_bug_fix code_object
+        core_pin = core_store.get_path_pins(code_object.path)
+                             .find { |pin| pin.is_a?(Pin::Constant) }
+        if core_pin
+          location = Helpers.object_location(code_object, @spec)
+          Solargraph.logger.warn "Adjusting YARD pin that conflicts with RBS core (#{code_object.inspect} #{location.inspect})"
+          Pin::Namespace.new(name: core_pin.return_type.namespace, location: location, source: :yard_map_hack)
+        else
+          ToNamespace.make(code_object, @spec, @namespace_pins[code_object.namespace.to_s])
+        end
+      end
     end
   end
 end

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.4
 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