solargraph 0.60.3 → 0.60.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0a62c1ebc82583e5c0ee905b75e3f065a1c6185c8268e7b529115fe445afb1a6
-  data.tar.gz: 8b4cc8722f4eb6b3aecb58aaec22d2db54c49a3b2f6477bc7019331de86fbfc7
+  metadata.gz: 7c7397d5a9bbee07b12baa9372ce14f61216e5a310aa0f68605acabf8a9430e2
+  data.tar.gz: aeecf5c5d1ea7b1040fd3ae4bd9d1bff1685e468bd92b30dedfdd8ded2f1cd04
 SHA512:
-  metadata.gz: 8882c0dffd4a6ac9c4d25c53fdb1789840951fa00860120a25237353c9aa4b2c3454bf04cd94921e56f52871a97978f3ea5b4ed38fba34841d8395eb1223a650
-  data.tar.gz: 5ec51b9ab0cb3d3f445e3282c0c132641a7c9bf52643598a4476ddc5eb23d5527442f0bd434f772b9fcc94a437a956b38607f13d9dc74752df69fae75017963b
+  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,13 @@
+## 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)

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/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?
@@ -747,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/source/chain/call.rb

@@ -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.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/version.rb

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

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

metadata

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