solargraph 0.54.1 → 0.56.0

data/lib/solargraph/pin/closure.rb

@@ -8,10 +8,27 @@ module Solargraph
 
       # @param scope [::Symbol] :class or :instance
       # @param generics [::Array<Pin::Parameter>, nil]
-      def initialize scope: :class, generics: nil, **splat
+      def initialize scope: :class, generics: nil, generic_defaults: {},  **splat
         super(**splat)
         @scope = scope
         @generics = generics
+        @generic_defaults = generic_defaults
+      end
+
+      def generic_defaults
+        @generic_defaults ||= {}
+      end
+
+      # @param other [self]
+      # @param attrs [Hash{Symbol => Object}]
+      #
+      # @return [self]
+      def combine_with(other, attrs={})
+        new_attrs = {
+          scope: assert_same(other, :scope),
+          generics: generics.empty? ? other.generics : generics,
+        }.merge(attrs)
+        super(other, new_attrs)
       end
 
       def context

data/lib/solargraph/pin/common.rb

@@ -9,6 +9,11 @@ module Solargraph
       # @return [Pin::Closure, nil]
       attr_reader :closure
 
+      def closure
+        Solargraph.assert_or_log(:closure, "Closure not set on #{self.class} #{name.inspect} from #{source.inspect}") unless @closure
+        @closure
+      end
+
       # @return [String]
       def name
         @name ||= ''

data/lib/solargraph/pin/delegated_method.rb

@@ -24,8 +24,26 @@ module Solargraph
         @receiver_method_name = receiver_method_name
       end
 
-      %i[comments parameters return_type location].each do |method|
+      def inner_desc
+        "#{name} => #{@receiver_chain}##{@receiver_method_name}"
+      end
+
+      def location
+        return super if super
+
+        @resolved_method&.send(:location)
+      end
+
+
+      def type_location
+        return super if super
+
+        @resolved_method&.send(:type_location)
+      end
+
+      %i[comments parameters return_type signatures].each do |method|
         define_method(method) do
+          # @sg-ignore Need to set context correctly in define_method blocks
           @resolved_method ? @resolved_method.send(method) : super()
         end
       end
@@ -34,6 +52,7 @@ module Solargraph
         # @param api_map [ApiMap]
         define_method(method) do |api_map|
           resolve_method(api_map)
+          # @sg-ignore Need to set context correctly in define_method blocks
           @resolved_method ? @resolved_method.send(method, api_map) : super(api_map)
         end
       end

data/lib/solargraph/pin/documenting.rb

@@ -9,6 +9,22 @@ require 'solargraph/converters/dt'
 require 'solargraph/converters/dd'
 require 'solargraph/converters/misc'
 
+# @todo upstream this definition
+
+# @!parse
+#   module ::Kramdown
+#     class Document
+#       # @return [String]
+#       def to_html; end
+#     end
+#   end
+#   module ReverseMarkdown
+#     # @param input [String]
+#     # @param options [Hash]
+#     # @return [String]
+#     def self.convert(input, options = {}); end
+#   end
+
 module Solargraph
   module Pin
     # A module to add the Pin::Base#documentation method.

data/lib/solargraph/pin/keyword.rb

@@ -3,8 +3,13 @@
 module Solargraph
   module Pin
     class Keyword < Base
-      def initialize name
-        super(name: name)
+      def initialize(name, **kwargs)
+        # @sg-ignore "Unrecognized keyword argument kwargs to Solargraph::Pin::Base#initialize"
+        super(name: name, **kwargs)
+      end
+
+      def closure
+        @closure ||= Pin::ROOT_PIN
       end
 
       def name

data/lib/solargraph/pin/local_variable.rb

@@ -6,20 +6,29 @@ module Solargraph
       # @return [Range]
       attr_reader :presence
 
+      def presence_certain?
+        @presence_certain
+      end
+
       # @param assignment [AST::Node, nil]
       # @param presence [Range, nil]
+      # @param presence_certain [Boolean]
       # @param splat [Hash]
-      def initialize assignment: nil, presence: nil, **splat
+      def initialize assignment: nil, presence: nil, presence_certain: false, **splat
         super(**splat)
         @assignment = assignment
         @presence = presence
+        @presence_certain = presence_certain
       end
 
-      # @param pin [self]
-      def try_merge! pin
-        return false unless super
-        @presence = pin.presence
-        true
+      def combine_with(other, attrs={})
+        new_attrs = {
+          assignment: assert_same(other, :assignment),
+          presence_certain: assert_same(other, :presence_certain?),
+        }.merge(attrs)
+        new_attrs[:presence] =  assert_same(other, :presence) unless attrs.key?(:presence)
+
+        super(other, new_attrs)
       end
 
       # @param other_closure [Pin::Closure]

data/lib/solargraph/pin/method.rb

@@ -10,6 +10,8 @@ module Solargraph
       # @return [::Symbol] :public, :private, or :protected
       attr_reader :visibility
 
+      attr_writer :signatures
+
       # @return [Parser::AST::Node]
       attr_reader :node
 
@@ -31,6 +33,74 @@ module Solargraph
         @anon_splat = anon_splat
       end
 
+      # @return [Array<Pin::Signature>]
+      def combine_all_signature_pins(*signature_pins)
+        by_arity = {}
+        signature_pins.each do |signature_pin|
+          by_arity[signature_pin.arity] ||= []
+          by_arity[signature_pin.arity] << signature_pin
+        end
+        by_arity.transform_values! do |same_arity_pins|
+          same_arity_pins.reduce(nil) do |memo, signature|
+            next signature if memo.nil?
+            memo.combine_with(signature)
+          end
+        end
+        by_arity.values.flatten
+      end
+
+      # @param other [Pin::Method]
+      # @return [Symbol]
+      def combine_visibility(other)
+        if dodgy_visibility_source? && !other.dodgy_visibility_source?
+          other.visibility
+        elsif other.dodgy_visibility_source? && !dodgy_visibility_source?
+          visibility
+        else
+          assert_same(other, :visibility)
+        end
+      end
+
+      # @param other [Pin::Method]
+      # @return [Array<Pin::Signature>]
+      def combine_signatures(other)
+        all_undefined = signatures.all? { |sig| sig.return_type.undefined? }
+        other_all_undefined = other.signatures.all? { |sig| sig.return_type.undefined? }
+        if all_undefined && !other_all_undefined
+          other.signatures
+        elsif other_all_undefined && !all_undefined
+          signatures
+        else
+          combine_all_signature_pins(*signatures, *other.signatures)
+        end
+      end
+
+      def combine_with(other, attrs = {})
+        sigs = combine_signatures(other)
+        parameters = if sigs.length > 0
+          [].freeze
+        else
+          choose(other, :parameters).clone.freeze
+        end
+        new_attrs = {
+          visibility: combine_visibility(other),
+          explicit: explicit? || other.explicit?,
+          block: combine_blocks(other),
+          node: choose_node(other, :node),
+          attribute: prefer_rbs_location(other, :attribute?),
+          parameters: parameters,
+          signatures: sigs,
+          anon_splat: assert_same(other, :anon_splat?),
+          return_type: nil # pulled from signatures on first call
+        }.merge(attrs)
+        super(other, new_attrs)
+      end
+
+      # @param other [Pin::Method]
+      def == other
+        super && other.node == node
+      end
+
       def transform_types(&transform)
         # @todo 'super' alone should work here I think, but doesn't typecheck at level typed
         m = super(&transform)
@@ -38,11 +108,24 @@ module Solargraph
           sig.transform_types(&transform)
         end
         m.block = block&.transform_types(&transform)
-        m.signature_help = nil
-        m.documentation = nil
+        m.reset_generated!
         m
       end
 
+      # @return [void]
+      def reset_generated!
+        super
+        unless signatures.empty?
+          return_type = nil
+          @block = :undefined
+          parameters = []
+        end
+        block&.reset_generated!
+        @signatures&.each(&:reset_generated!)
+        signature_help = nil
+        documentation = nil
+      end
+
       def all_rooted?
         super && parameters.all?(&:all_rooted?) && (!block || block&.all_rooted?) && signatures.all?(&:all_rooted?)
       end
@@ -51,8 +134,7 @@ module Solargraph
       # @return [Pin::Method]
       def with_single_signature(signature)
         m = proxy signature.return_type
-        m.signature_help = nil
-        m.documentation = nil
+        m.reset_generated!
         # @todo populating the single parameters/return_type/block
         #   arguments here seems to be needed for some specs to pass,
         #   even though we have a signature with the same information.
@@ -112,13 +194,16 @@ module Solargraph
               name: name,
               decl: decl,
               presence: location ? location.range : nil,
-              return_type: ComplexType.try_parse(*p.types)
+              return_type: ComplexType.try_parse(*p.types),
+              source: source
             )
           end
           yield_return_type = ComplexType.try_parse(*yieldreturn_tags.flat_map(&:types))
-          block = Signature.new(generics: generics, parameters: yield_parameters, return_type: yield_return_type)
+          block = Signature.new(generics: generics, parameters: yield_parameters, return_type: yield_return_type, source: source, closure: self)
         end
-        Signature.new(generics: generics, parameters: parameters, return_type: return_type, block: block)
+        signature = Signature.new(generics: generics, parameters: parameters, return_type: return_type, block: block, closure: self, source: source)
+        block.closure = signature if block
+        signature
       end
 
       # @return [::Array<Signature>]
@@ -133,6 +218,14 @@ module Solargraph
         end
       end
 
+      # @param return_type [ComplexType]
+      # @return [self]
+      def proxy_with_signatures return_type
+        out = proxy return_type
+        out.signatures = out.signatures.map { |sig| sig.proxy return_type }
+        out
+      end
+
       # @return [String, nil]
       def detail
         # This property is not cached in an instance variable because it can
@@ -159,12 +252,12 @@ module Solargraph
         end
       end
 
-      def desc
+      def inner_desc
         # ensure the signatures line up when logged
         if signatures.length > 1
-          "\n#{to_rbs}\n"
+          path + " \n#{to_rbs}\n"
         else
-          to_rbs
+          super
         end
       end
 
@@ -184,21 +277,36 @@ module Solargraph
         @path ||= "#{namespace}#{(scope == :instance ? '#' : '.')}#{name}"
       end
 
+      # @return [String]
+      def method_name
+        name
+      end
+
       def typify api_map
+        logger.debug { "Method#typify(self=#{self}, binder=#{binder}, closure=#{closure}, context=#{context.rooted_tags}, return_type=#{return_type.rooted_tags}) - starting" }
         decl = super
-        return decl unless decl.undefined?
+        unless decl.undefined?
+          logger.debug { "Method#typify(self=#{self}, binder=#{binder}, closure=#{closure}, context=#{context}) => #{decl.rooted_tags.inspect} - decl found" }
+          return decl
+        end
         type = see_reference(api_map) || typify_from_super(api_map)
-        return type.qualify(api_map, namespace) unless type.nil?
-        name.end_with?('?') ? ComplexType::BOOLEAN : ComplexType::UNDEFINED
+        logger.debug { "Method#typify(self=#{self}) - type=#{type&.rooted_tags.inspect}" }
+        unless type.nil?
+          qualified = type.qualify(api_map, namespace)
+          logger.debug { "Method#typify(self=#{self}) => #{qualified.rooted_tags.inspect}" }
+          return qualified
+        end
+        super
       end
 
+      # @sg-ignore
       def documentation
         if @documentation.nil?
-          @documentation ||= super || ''
+          method_docs ||= super || ''
           param_tags = docstring.tags(:param)
           unless param_tags.nil? or param_tags.empty?
-            @documentation += "\n\n" unless @documentation.empty?
-            @documentation += "Params:\n"
+            method_docs += "\n\n" unless method_docs.empty?
+            method_docs += "Params:\n"
             lines = []
             param_tags.each do |p|
               l = "* #{p.name}"
@@ -206,12 +314,12 @@ module Solargraph
               l += " #{p.text}"
               lines.push l
             end
-            @documentation += lines.join("\n")
+            method_docs += lines.join("\n")
           end
           yieldparam_tags = docstring.tags(:yieldparam)
           unless yieldparam_tags.nil? or yieldparam_tags.empty?
-            @documentation += "\n\n" unless @documentation.empty?
-            @documentation += "Block Params:\n"
+            method_docs += "\n\n" unless method_docs.empty?
+            method_docs += "Block Params:\n"
             lines = []
             yieldparam_tags.each do |p|
               l = "* #{p.name}"
@@ -219,12 +327,12 @@ module Solargraph
               l += " #{p.text}"
               lines.push l
             end
-            @documentation += lines.join("\n")
+            method_docs += lines.join("\n")
           end
           yieldreturn_tags = docstring.tags(:yieldreturn)
           unless yieldreturn_tags.empty?
-            @documentation += "\n\n" unless @documentation.empty?
-            @documentation += "Block Returns:\n"
+            method_docs += "\n\n" unless method_docs.empty?
+            method_docs += "Block Returns:\n"
             lines = []
             yieldreturn_tags.each do |r|
               l = "*"
@@ -232,12 +340,12 @@ module Solargraph
               l += " #{r.text}"
               lines.push l
             end
-            @documentation += lines.join("\n")
+            method_docs += lines.join("\n")
           end
           return_tags = docstring.tags(:return)
           unless return_tags.empty?
-            @documentation += "\n\n" unless @documentation.empty?
-            @documentation += "Returns:\n"
+            method_docs += "\n\n" unless method_docs.empty?
+            method_docs += "Returns:\n"
             lines = []
             return_tags.each do |r|
               l = "*"
@@ -245,10 +353,11 @@ module Solargraph
               l += " #{r.text}"
               lines.push l
             end
-            @documentation += lines.join("\n")
+            method_docs += lines.join("\n")
           end
-          @documentation += "\n\n" unless @documentation.empty?
-          @documentation += "Visibility: #{visibility}"
+          method_docs += "\n\n" unless method_docs.empty?
+          method_docs += "Visibility: #{visibility}"
+          @documentation = method_docs
           concat_example_tags
         end
         @documentation.to_s
@@ -262,6 +371,7 @@ module Solargraph
         @attribute
       end
 
+      # @parm other [Method]
       def nearly? other
         super &&
           parameters == other.parameters &&
@@ -273,13 +383,6 @@ module Solargraph
         attribute? ? infer_from_iv(api_map) : infer_from_return_nodes(api_map)
       end
 
-      def try_merge! pin
-        return false unless super
-        @node = pin.node
-        @resolved_ref_tag = false
-        true
-      end
-
       # @return [::Array<Pin::Method>]
       def overloads
         # Ignore overload tags with nil parameters. If it's not an array, the
@@ -296,10 +399,13 @@ module Solargraph
                 name: name,
                 decl: decl,
                 presence: location ? location.range : nil,
-                return_type: param_type_from_name(tag, src.first)
+                return_type: param_type_from_name(tag, src.first),
+                source: :overloads
               )
             end,
-            return_type: ComplexType.try_parse(*tag.docstring.tags(:return).flat_map(&:types))
+            closure: self,
+            return_type: ComplexType.try_parse(*tag.docstring.tags(:return).flat_map(&:types)),
+            source: :overloads,
           )
         end
         @overloads
@@ -309,7 +415,7 @@ module Solargraph
         @anon_splat
       end
 
-      # @param [ApiMap]
+      # @param api_map [ApiMap]
       # @return [self]
       def resolve_ref_tag api_map
         return self if @resolved_ref_tag
@@ -332,16 +438,35 @@ module Solargraph
         self
       end
 
+      # @param api_map [ApiMap]
+      # @return [Array<Pin::Method>]
+      def rest_of_stack api_map
+        api_map.get_method_stack(method_namespace, method_name, scope: scope).reject { |pin| pin.path == path }
+      end
+
       protected
 
       attr_writer :block
 
-      attr_writer :signatures
-
       attr_writer :signature_help
 
       attr_writer :documentation
 
+      def dodgy_visibility_source?
+        # as of 2025-03-12, the RBS generator used for
+        # e.g. activesupport did not understand 'private' markings
+        # inside 'class << self' blocks, but YARD did OK at it
+        source == :rbs && scope == :class && type_location&.filename&.include?('generated') && return_type.undefined? ||
+          # YARD's RBS generator seems to miss a lot of should-be protected instance methods
+          source == :rbs && scope == :instance && namespace.start_with?('YARD::') ||
+          # private on attr_readers seems to be broken in Prism's auto-generator script
+          source == :rbs && scope == :instance && namespace.start_with?('Prism::') ||
+          # The RBS for the RBS gem itself seems to use private as a
+          # 'is this a public API' concept, more aggressively than the
+          # actual code.  Let's respect that and ignore the actual .rb file.
+          source == :yardoc && scope == :instance && namespace.start_with?('RBS::')
+      end
+
       private
 
       # @param name [String]
@@ -402,10 +527,15 @@ module Solargraph
         resolve_reference match[1], api_map
       end
 
+      # @return [String]
+      def method_namespace
+        namespace
+      end
+
       # @param api_map [ApiMap]
       # @return [ComplexType, nil]
       def typify_from_super api_map
-        stack = api_map.get_method_stack(namespace, name, scope: scope).reject { |pin| pin.path == path }
+        stack = rest_of_stack api_map
         return nil if stack.empty?
         stack.each do |pin|
           return pin.return_type unless pin.return_type.undefined?
@@ -515,7 +645,7 @@ module Solargraph
 
       protected
 
-      attr_writer :signatures
+      attr_writer :return_type
     end
   end
 end

data/lib/solargraph/pin/namespace.rb

@@ -11,44 +11,52 @@ module Solargraph
       # @return [::Symbol] :class or :module
       attr_reader :type
 
+      # does not assert like super, as a namespace without a closure
+      # may be the root level namespace, or it may not yet be
+      # qualified
+      attr_reader :closure
+
       # @param type [::Symbol] :class or :module
       # @param visibility [::Symbol] :public or :private
       # @param gates [::Array<String>]
-      def initialize type: :class, visibility: :public, gates: [''], **splat
+      # @param name [String]
+      def initialize type: :class, visibility: :public, gates: [''], name: '', **splat
         # super(location, namespace, name, comments)
-        super(**splat)
+        super(**splat, name: name)
         @type = type
         @visibility = visibility
         if name.start_with?('::')
-          @name = name[2..-1]
+          # @type [String]
+          name = name[2..-1] || ''
           @closure = Solargraph::Pin::ROOT_PIN
         end
         @open_gates = gates
-        if @name.include?('::')
+        if name.include?('::')
           # In this case, a chained namespace was opened (e.g., Foo::Bar)
           # but Foo does not exist.
-          parts = @name.split('::')
-          @name = parts.pop
+          parts = name.split('::')
+          name = parts.pop
           closure_name = if [Solargraph::Pin::ROOT_PIN, nil].include?(closure)
             ''
           else
             closure.full_context.namespace + '::'
           end
           closure_name += parts.join('::')
-          @closure = Pin::Namespace.new(name: closure_name, gates: [parts.join('::')])
+          @closure = Pin::Namespace.new(name: closure_name, gates: [parts.join('::')], source: :namespace)
           @context = nil
         end
+        @name = name
       end
 
       def to_rbs
         "#{@type.to_s} #{return_type.all_params.first.to_rbs}#{rbs_generics}".strip
       end
 
-      def desc
+      def inner_desc
         if name.nil? || name.empty?
           '(top-level)'
         else
-          to_rbs
+          super
         end
       end