solargraph 0.55.4 → 0.56.0

data/lib/solargraph/pin/method.rb

@@ -33,6 +33,70 @@ 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
@@ -44,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
@@ -57,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.
@@ -123,7 +199,7 @@ module Solargraph
             )
           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, source: source)
+          block = Signature.new(generics: generics, parameters: yield_parameters, return_type: yield_return_type, source: source, closure: self)
         end
         signature = Signature.new(generics: generics, parameters: parameters, return_type: return_type, block: block, closure: self, source: source)
         block.closure = signature if block
@@ -142,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
@@ -193,12 +277,26 @@ 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
@@ -285,14 +383,6 @@ module Solargraph
         attribute? ? infer_from_iv(api_map) : infer_from_return_nodes(api_map)
       end
 
-      # @param pin [Pin::Method]
-      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
@@ -313,6 +403,7 @@ module Solargraph
                 source: :overloads
               )
             end,
+            closure: self,
             return_type: ComplexType.try_parse(*tag.docstring.tags(:return).flat_map(&:types)),
             source: :overloads,
           )
@@ -347,6 +438,12 @@ 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
@@ -355,6 +452,21 @@ module Solargraph
 
       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]
@@ -415,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?

data/lib/solargraph/pin/parameter.rb

@@ -21,6 +21,23 @@ module Solargraph
         @decl = decl
       end
 
+      def type_location
+        super || closure&.type_location
+      end
+
+      def location
+        super || closure&.type_location
+      end
+
+      def combine_with(other, attrs={})
+        new_attrs = {
+          decl: assert_same(other, :decl),
+          presence: choose(other, :presence),
+          asgn_code: choose(other, :asgn_code),
+        }.merge(attrs)
+        super(other, new_attrs)
+      end
+
       def keyword?
         [:kwarg, :kwoptarg].include?(decl)
       end
@@ -29,6 +46,32 @@ module Solargraph
         decl == :kwrestarg || (assignment && [:HASH, :hash].include?(assignment.type))
       end
 
+      def needs_consistent_name?
+        keyword?
+      end
+
+      # @return [String]
+      def arity_decl
+        name = (self.name || '(anon)')
+        type = (return_type&.to_rbs || 'untyped')
+        case decl
+        when :arg
+          ""
+        when :optarg
+          "?"
+        when :kwarg
+          "#{name}:"
+        when :kwoptarg
+          "?#{name}:"
+        when :restarg
+          "*"
+        when :kwrestarg
+          "**"
+        else
+          "(unknown decl: #{decl})"
+        end
+      end
+
       def arg?
         decl == :arg
       end
@@ -132,12 +175,6 @@ module Solargraph
         tag.text
       end
 
-      # @param pin [Pin::Parameter]
-      def try_merge! pin
-        return false unless super && closure == pin.closure
-        true
-      end
-
       private
 
       # @return [YARD::Tags::Tag, nil]

data/lib/solargraph/pin/signature.rb

@@ -16,6 +16,44 @@ module Solargraph
       def identity
         @identity ||= "signature#{object_id}"
       end
+
+      attr_writer :closure
+
+      def dodgy_return_type_source?
+        super || closure&.dodgy_return_type_source?
+      end
+
+      def type_location
+        super || closure&.type_location
+      end
+
+      def location
+        super || closure&.location
+      end
+
+      def typify api_map
+        if return_type.defined?
+          qualified = return_type.qualify(api_map, closure.namespace)
+          logger.debug { "Signature#typify(self=#{self}) => #{qualified.rooted_tags.inspect}" }
+          return qualified
+        end
+        return ComplexType::UNDEFINED if closure.nil?
+        return ComplexType::UNDEFINED unless closure.is_a?(Pin::Method)
+        method_stack = closure.rest_of_stack api_map
+        logger.debug { "Signature#typify(self=#{self}) - method_stack: #{method_stack}" }
+        method_stack.each do |pin|
+          sig = pin.signatures.find { |s| s.arity == self.arity }
+          next unless sig
+          unless sig.return_type.undefined?
+            qualified = sig.return_type.qualify(api_map, closure.namespace)
+            logger.debug { "Signature#typify(self=#{self}) => #{qualified.rooted_tags.inspect}" }
+            return qualified
+          end
+        end
+        out = super
+        logger.debug { "Signature#typify(self=#{self}) => #{out}" }
+        out
+      end
     end
   end
 end

data/lib/solargraph/pin_cache.rb

@@ -0,0 +1,185 @@
+require 'fileutils'
+require 'rbs'
+
+module Solargraph
+  module PinCache
+    class << self
+      include Logging
+
+      # The base directory where cached YARD documentation and serialized pins are serialized
+      #
+      # @return [String]
+      def base_dir
+        # The directory is not stored in a variable so it can be overridden
+        # in specs.
+        ENV['SOLARGRAPH_CACHE'] ||
+          (ENV['XDG_CACHE_HOME'] ? File.join(ENV['XDG_CACHE_HOME'], 'solargraph') : nil) ||
+          File.join(Dir.home, '.cache', 'solargraph')
+      end
+
+      # The working directory for the current Ruby, RBS, and Solargraph versions.
+      #
+      # @return [String]
+      def work_dir
+        # The directory is not stored in a variable so it can be overridden
+        # in specs.
+        File.join(base_dir, "ruby-#{RUBY_VERSION}", "rbs-#{RBS::VERSION}", "solargraph-#{Solargraph::VERSION}")
+      end
+
+      def yardoc_path gemspec
+        File.join(base_dir, "yard-#{YARD::VERSION}", "#{gemspec.name}-#{gemspec.version}.yardoc")
+      end
+
+      def stdlib_path
+        File.join(work_dir, 'stdlib')
+      end
+
+      def stdlib_require_path require
+        File.join(stdlib_path, "#{require}.ser")
+      end
+
+      def deserialize_stdlib_require require
+        load(stdlib_require_path(require))
+      end
+
+      def serialize_stdlib_require require, pins
+        save(stdlib_require_path(require), pins)
+      end
+
+      def core_path
+        File.join(work_dir, 'core.ser')
+      end
+
+      def deserialize_core
+        load(core_path)
+      end
+
+      def serialize_core pins
+        save(core_path, pins)
+      end
+
+      def yard_gem_path gemspec
+        File.join(work_dir, 'yard', "#{gemspec.name}-#{gemspec.version}.ser")
+      end
+
+      def deserialize_yard_gem(gemspec)
+        load(yard_gem_path(gemspec))
+      end
+
+      def serialize_yard_gem(gemspec, pins)
+        save(yard_gem_path(gemspec), pins)
+      end
+
+      def has_yard?(gemspec)
+        exist?(yard_gem_path(gemspec))
+      end
+
+      def rbs_collection_path(gemspec, hash)
+        File.join(work_dir, 'rbs', "#{gemspec.name}-#{gemspec.version}-#{hash || 0}.ser")
+      end
+
+      def rbs_collection_path_prefix(gemspec)
+        File.join(work_dir, 'rbs', "#{gemspec.name}-#{gemspec.version}-")
+      end
+
+      def deserialize_rbs_collection_gem(gemspec, hash)
+        load(rbs_collection_path(gemspec, hash))
+      end
+
+      def serialize_rbs_collection_gem(gemspec, hash, pins)
+        save(rbs_collection_path(gemspec, hash), pins)
+      end
+
+      def combined_path(gemspec, hash)
+        File.join(work_dir, 'combined', "#{gemspec.name}-#{gemspec.version}-#{hash || 0}.ser")
+      end
+
+      def combined_path_prefix(gemspec)
+        File.join(work_dir, 'combined', "#{gemspec.name}-#{gemspec.version}-")
+      end
+
+      def serialize_combined_gem(gemspec, hash, pins)
+        save(combined_path(gemspec, hash), pins)
+      end
+
+      def deserialize_combined_gem gemspec, hash
+        load(combined_path(gemspec, hash))
+      end
+
+      def has_rbs_collection?(gemspec, hash)
+        exist?(rbs_collection_path(gemspec, hash))
+      end
+
+      def uncache_core
+        uncache(core_path)
+      end
+
+      def uncache_stdlib
+        uncache(stdlib_path)
+      end
+
+      def uncache_gem(gemspec, out: nil)
+        uncache(yardoc_path(gemspec), out: out)
+        uncache_by_prefix(rbs_collection_path_prefix(gemspec), out: out)
+        uncache(yard_gem_path(gemspec), out: out)
+        uncache_by_prefix(combined_path_prefix(gemspec), out: out)
+      end
+
+      # @return [void]
+      def clear
+        FileUtils.rm_rf base_dir, secure: true
+      end
+
+      private
+
+      # @param file [String]
+      # @return [Array<Solargraph::Pin::Base>, nil]
+      def load file
+        return nil unless File.file?(file)
+        Marshal.load(File.read(file, mode: 'rb'))
+      rescue StandardError => e
+        Solargraph.logger.warn "Failed to load cached file #{file}: [#{e.class}] #{e.message}"
+        FileUtils.rm_f file
+        nil
+      end
+
+      def exist? *path
+        File.file? join(*path)
+      end
+
+      # @param path [Array<String>]
+      # @param pins [Array<Pin::Base>]
+      # @return [void]
+      def save file, pins
+        base = File.dirname(file)
+        FileUtils.mkdir_p base unless File.directory?(base)
+        ser = Marshal.dump(pins)
+        File.write file, ser, mode: 'wb'
+        logger.debug { "Cache#save: Saved #{pins.length} pins to #{file}" }
+      end
+
+      # @return [void]
+      # @param path_segments [Array<String>]
+      def uncache *path_segments, out: nil
+        path = File.join(*path_segments)
+        if File.exist?(path)
+          FileUtils.rm_rf path, secure: true
+          out.puts "Clearing pin cache in #{path}" unless out.nil?
+        end
+      end
+
+      # @return [void]
+      # @param path_segments [Array<String>]
+      def uncache_by_prefix *path_segments, out: nil
+        path = File.join(*path_segments)
+        glob = "#{path}*"
+        out.puts "Clearing pin cache in #{glob}" unless out.nil?
+        Dir.glob(glob).each do |file|
+          next unless File.file?(file)
+          FileUtils.rm_rf file, secure: true
+          out.puts "Clearing pin cache in #{file}" unless out.nil?
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/position.rb

@@ -26,6 +26,15 @@ module Solargraph
       [line, character]
     end
 
+    def <=>(other)
+      return nil unless other.is_a?(Position)
+      if line == other.line
+        character <=> other.character
+      else
+        line <=> other.line
+      end
+    end
+
     # Get a hash of the position. This representation is suitable for use in
     # the language server protocol.
     #

data/lib/solargraph/range.rb

@@ -24,6 +24,15 @@ module Solargraph
       [start, ending]
     end
 
+    def <=>(other)
+      return nil unless other.is_a?(Range)
+      if start == other.start
+        ending <=> other.ending
+      else
+        start <=> other.start
+      end
+    end
+
     # Get a hash of the range. This representation is suitable for use in
     # the language server protocol.
     #

data/lib/solargraph/rbs_map/conversions.rb

@@ -6,7 +6,7 @@ module Solargraph
   class RbsMap
     # Functions for converting RBS declarations to Solargraph pins
     #
-    module Conversions
+    class Conversions
       include Logging
 
       # A container for tracking the current context of the RBS conversion
@@ -22,11 +22,17 @@ module Solargraph
         end
       end
 
-      # @return [Array<Pin::Base>]
-      def pins
-        @pins ||= []
+      def initialize(loader:)
+        @loader = loader
+        @pins = []
+        load_environment_to_pins(loader)
       end
 
+      attr_reader :loader
+
+      # @return [Array<Pin::Base>]
+      attr_reader :pins
+
       private
 
       # @return [Hash{String => RBS::AST::Declarations::TypeAlias}]
@@ -39,6 +45,10 @@ module Solargraph
       def load_environment_to_pins(loader)
         environment = RBS::Environment.from_loader(loader).resolve_type_names
         cursor = pins.length
+        if environment.declarations.empty?
+          Solargraph.logger.info "No RBS declarations found in environment for core_root #{loader.core_root.inspect}, libraries #{loader.libs} and directories #{loader.dirs}"
+          return
+        end
         environment.declarations.each { |decl| convert_decl_to_pin(decl, Solargraph::Pin::ROOT_PIN) }
       end
 
@@ -488,7 +498,7 @@ module Solargraph
           type_location: location_decl_to_pin_location(decl.location),
           closure: closure,
           comments: decl.comment&.string,
-          scope: :instance,
+          scope: final_scope,
           attribute: true,
           visibility: visibility,
           source: :rbs
@@ -512,7 +522,7 @@ module Solargraph
           closure: closure,
           parameters: [],
           comments: decl.comment&.string,
-          scope: :instance,
+          scope: final_scope,
           attribute: true,
           visibility: visibility,
           source: :rbs
@@ -628,11 +638,13 @@ module Solargraph
       # @param closure [Pin::Namespace]
       # @return [void]
       def alias_to_pin decl, closure
+        final_scope = decl.singleton? ? :class : :instance
         pins.push Solargraph::Pin::MethodAlias.new(
           name: decl.new_name.to_s,
           type_location: location_decl_to_pin_location(decl.location),
           original: decl.old_name.to_s,
           closure: closure,
+          scope: final_scope,
           source: :rbs,
         )
       end
@@ -683,8 +695,7 @@ module Solargraph
         if type.is_a?(RBS::Types::Optional)
           "#{other_type_to_tag(type.type)}, nil"
         elsif type.is_a?(RBS::Types::Bases::Any)
-          # @todo Not sure what to do with Any yet
-          'BasicObject'
+          'undefined'
         elsif type.is_a?(RBS::Types::Bases::Bool)
           'Boolean'
         elsif type.is_a?(RBS::Types::Tuple)

data/lib/solargraph/rbs_map/core_map.rb

@@ -5,24 +5,46 @@ module Solargraph
     # Ruby core pins
     #
     class CoreMap
-      include Conversions
+
+      def resolved?
+        true
+      end
 
       FILLS_DIRECTORY = File.join(File.dirname(__FILE__), '..', '..', '..', 'rbs', 'fills')
 
-      def initialize
-        cache = Cache.load('core.ser')
+      def initialize; end
+
+      def pins
+        return @pins if @pins
+
+        @pins = []
+        cache = PinCache.deserialize_core
         if cache
-          pins.replace cache
+          @pins.replace cache
         else
-          loader = RBS::EnvironmentLoader.new(repository: RBS::Repository.new(no_stdlib: false))
           loader.add(path: Pathname(FILLS_DIRECTORY))
-          load_environment_to_pins(loader)
-          pins.concat RbsMap::CoreFills::ALL
+          @pins = conversions.pins
+          @pins.concat RbsMap::CoreFills::ALL
           processed = ApiMap::Store.new(pins).pins.reject { |p| p.is_a?(Solargraph::Pin::Reference::Override) }
-          pins.replace processed
+          @pins.replace processed
 
-          Cache.save('core.ser', pins)
+          PinCache.serialize_core @pins
         end
+        @pins
+      end
+
+      def loader
+        @loader ||= RBS::EnvironmentLoader.new(repository: RBS::Repository.new(no_stdlib: false))
+      end
+
+      private
+
+      def loader
+        @loader ||= RBS::EnvironmentLoader.new(repository: RBS::Repository.new(no_stdlib: false))
+      end
+
+      def conversions
+        @conversions ||= Conversions.new(loader: loader)
       end
     end
   end