solargraph 0.55.3 → 0.56.1

data/lib/solargraph/doc_map.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require 'pathname'
+require 'benchmark'
+
 module Solargraph
   # A collection of pins generated from required gems.
   #
@@ -8,6 +11,7 @@ module Solargraph
 
     # @return [Array<String>]
     attr_reader :requires
+    alias required requires
 
     # @return [Array<Gem::Specification>]
     attr_reader :preferences
@@ -16,11 +20,28 @@ module Solargraph
     attr_reader :pins
 
     # @return [Array<Gem::Specification>]
-    attr_reader :uncached_gemspecs
+    def uncached_gemspecs
+      uncached_yard_gemspecs.concat(uncached_rbs_collection_gemspecs)
+                            .sort
+                            .uniq { |gemspec| "#{gemspec.name}:#{gemspec.version}" }
+    end
+
+    # @return [Array<Gem::Specification>]
+    attr_reader :uncached_yard_gemspecs
+
+    # @return [Array<Gem::Specification>]
+    attr_reader :uncached_rbs_collection_gemspecs
+
+    attr_reader :rbs_collection_path
+
+    attr_reader :rbs_collection_config_path
 
     # @return [Workspace, nil]
     attr_reader :workspace
 
+    # @return [Environ]
+    attr_reader :environ
+
     # @param requires [Array<String>]
     # @param preferences [Array<Gem::Specification>]
     # @param workspace [Workspace, nil]
@@ -28,7 +49,58 @@ module Solargraph
       @requires = requires.compact
       @preferences = preferences.compact
       @workspace = workspace
-      generate
+      @rbs_collection_path = workspace&.rbs_collection_path
+      @rbs_collection_config_path = workspace&.rbs_collection_config_path
+      @environ = Convention.for_global(self)
+      load_serialized_gem_pins
+      pins.concat @environ.pins
+    end
+
+    def cache_all!(out)
+      # if we log at debug level:
+      if logger.info?
+        gem_desc = uncached_gemspecs.map { |gemspec| "#{gemspec.name}:#{gemspec.version}" }.join(', ')
+        logger.info "Caching pins for gems: #{gem_desc}" unless uncached_gemspecs.empty?
+      end
+      logger.debug { "Caching for YARD: #{uncached_yard_gemspecs.map(&:name)}" }
+      logger.debug { "Caching for RBS collection: #{uncached_rbs_collection_gemspecs.map(&:name)}" }
+      load_serialized_gem_pins
+      uncached_gemspecs.each do |gemspec|
+        cache(gemspec, out: out)
+      end
+      load_serialized_gem_pins
+      @uncached_rbs_collection_gemspecs = []
+      @uncached_yard_gemspecs = []
+    end
+
+    def cache_yard_pins(gemspec, out)
+      pins = GemPins.build_yard_pins(gemspec)
+      PinCache.serialize_yard_gem(gemspec, pins)
+      logger.info { "Cached #{pins.length} YARD pins for gem #{gemspec.name}:#{gemspec.version}" } unless pins.empty?
+    end
+
+    def cache_rbs_collection_pins(gemspec, out)
+      rbs_map = RbsMap.from_gemspec(gemspec, rbs_collection_path, rbs_collection_config_path)
+      pins = rbs_map.pins
+      rbs_version_cache_key = rbs_map.cache_key
+      # cache pins even if result is zero, so we don't retry building pins
+      pins ||= []
+      PinCache.serialize_rbs_collection_gem(gemspec, rbs_version_cache_key, pins)
+      logger.info { "Cached #{pins.length} RBS collection pins for gem #{gemspec.name} #{gemspec.version} with cache_key #{rbs_version_cache_key.inspect}" unless pins.empty? }
+    end
+
+    # @param gemspec [Gem::Specification]
+    def cache(gemspec, rebuild: false, out: nil)
+      build_yard = uncached_yard_gemspecs.include?(gemspec) || rebuild
+      build_rbs_collection = uncached_rbs_collection_gemspecs.include?(gemspec) || rebuild
+      if build_yard || build_rbs_collection
+        type = []
+        type << 'YARD' if build_yard
+        type << 'RBS collection' if build_rbs_collection
+        out.puts("Caching #{type.join(' and ')} pins for gem #{gemspec.name}:#{gemspec.version}") if out
+      end
+      cache_yard_pins(gemspec, out) if build_yard
+      cache_rbs_collection_pins(gemspec, out) if build_rbs_collection
     end
 
     # @return [Array<Gem::Specification>]
@@ -41,9 +113,28 @@ module Solargraph
       @unresolved_requires ||= required_gems_map.select { |_, gemspecs| gemspecs.nil? }.keys
     end
 
-    # @return [Hash{Gem::Specification => Array[Pin::Base]}]
-    def self.gems_in_memory
-      @gems_in_memory ||= {}
+    def self.all_yard_gems_in_memory
+      @yard_gems_in_memory ||= {}
+    end
+
+    def self.all_rbs_collection_gems_in_memory
+      @rbs_collection_gems_in_memory ||= {}
+    end
+
+    def yard_pins_in_memory
+      self.class.all_yard_gems_in_memory
+    end
+
+    def rbs_collection_pins_in_memory
+      self.class.all_rbs_collection_gems_in_memory[rbs_collection_path] ||= {}
+    end
+
+    def self.all_combined_pins_in_memory
+      @combined_pins_in_memory ||= {}
+    end
+
+    def combined_pins_in_memory
+      self.class.all_combined_pins_in_memory
     end
 
     # @return [Set<Gem::Specification>]
@@ -54,20 +145,29 @@ module Solargraph
     private
 
     # @return [void]
-    def generate
+    def load_serialized_gem_pins
       @pins = []
-      @uncached_gemspecs = []
-      required_gems_map.each do |path, gemspecs|
-        if gemspecs.nil?
-          try_stdlib_map path
-        else
-          gemspecs.each do |gemspec|
-            try_cache gemspec
-          end
+      @uncached_yard_gemspecs = []
+      @uncached_rbs_collection_gemspecs = []
+      with_gemspecs, without_gemspecs = required_gems_map.partition { |_, v| v }
+      paths = Hash[without_gemspecs].keys
+      gemspecs = Hash[with_gemspecs].values.flatten.compact + dependencies.to_a
+
+      paths.each do |path|
+        rbs_pins = deserialize_stdlib_rbs_map path
+      end
+
+      logger.debug { "DocMap#load_serialized_gem_pins: Combining pins..." }
+      time = Benchmark.measure do
+        gemspecs.each do |gemspec|
+          pins = deserialize_combined_pin_cache gemspec
+          @pins.concat pins if pins
         end
       end
-      dependencies.each { |dep| try_cache dep }
-      @uncached_gemspecs.uniq!
+      logger.info { "DocMap#load_serialized_gem_pins: Loaded and processed serialized pins together in #{time.real} seconds" }
+      @uncached_yard_gemspecs.uniq!
+      @uncached_rbs_collection_gemspecs.uniq!
+      nil
     end
 
     # @return [Hash{String => Array<Gem::Specification>}]
@@ -80,32 +180,97 @@ module Solargraph
       @preference_map ||= preferences.to_h { |gemspec| [gemspec.name, gemspec] }
     end
 
+    # @param gemspec [Gem::Specification]
+    # @return [Array<Pin::Base>]
+    def deserialize_yard_pin_cache gemspec
+      if yard_pins_in_memory.key?([gemspec.name, gemspec.version])
+        return yard_pins_in_memory[[gemspec.name, gemspec.version]]
+      end
+
+      cached = PinCache.deserialize_yard_gem(gemspec)
+      if cached
+        logger.info { "Loaded #{cached.length} cached YARD pins from #{gemspec.name}:#{gemspec.version}" }
+        yard_pins_in_memory[[gemspec.name, gemspec.version]] = cached
+        cached
+      else
+        logger.debug "No YARD pin cache for #{gemspec.name}:#{gemspec.version}"
+        @uncached_yard_gemspecs.push gemspec
+        nil
+      end
+    end
+
     # @param gemspec [Gem::Specification]
     # @return [void]
-    def try_cache gemspec
-      return if try_gem_in_memory(gemspec)
-      cache_file = File.join('gems', "#{gemspec.name}-#{gemspec.version}.ser")
-      if Cache.exist?(cache_file)
-        cached = Cache.load(cache_file)
-        gempins = update_from_collection(gemspec, cached)
-        self.class.gems_in_memory[gemspec] = gempins
-        @pins.concat gempins
+    def deserialize_combined_pin_cache(gemspec)
+      unless combined_pins_in_memory[[gemspec.name, gemspec.version]].nil?
+        return combined_pins_in_memory[[gemspec.name, gemspec.version]]
+      end
+
+      rbs_map = RbsMap.from_gemspec(gemspec, rbs_collection_path, rbs_collection_config_path)
+      rbs_version_cache_key = rbs_map.cache_key
+
+      cached = PinCache.deserialize_combined_gem(gemspec, rbs_version_cache_key)
+      if cached
+        logger.info { "Loaded #{cached.length} cached YARD pins from #{gemspec.name}:#{gemspec.version}" }
+        combined_pins_in_memory[[gemspec.name, gemspec.version]] = cached
+        return combined_pins_in_memory[[gemspec.name, gemspec.version]]
+      end
+
+      rbs_collection_pins = deserialize_rbs_collection_cache gemspec, rbs_version_cache_key
+
+      yard_pins = deserialize_yard_pin_cache gemspec
+
+      if !rbs_collection_pins.nil? && !yard_pins.nil?
+        logger.debug { "Combining pins for #{gemspec.name}:#{gemspec.version}" }
+        combined_pins = GemPins.combine(yard_pins, rbs_collection_pins)
+        PinCache.serialize_combined_gem(gemspec, rbs_version_cache_key, combined_pins)
+        combined_pins_in_memory[[gemspec.name, gemspec.version]] = combined_pins
+        logger.info { "Generated #{combined_pins_in_memory[[gemspec.name, gemspec.version]].length} combined pins for #{gemspec.name} #{gemspec.version}" }
+        return combined_pins
+      end
+
+      if !yard_pins.nil?
+        logger.debug { "Using only YARD pins for #{gemspec.name}:#{gemspec.version}" }
+        combined_pins_in_memory[[gemspec.name, gemspec.version]] = yard_pins
+        return combined_pins_in_memory[[gemspec.name, gemspec.version]]
+      elsif !rbs_collection_pins.nil?
+        logger.debug { "Using only RBS collection pins for #{gemspec.name}:#{gemspec.version}" }
+        combined_pins_in_memory[[gemspec.name, gemspec.version]] = rbs_collection_pins
+        return combined_pins_in_memory[[gemspec.name, gemspec.version]]
       else
-        Solargraph.logger.debug "No pin cache for #{gemspec.name} #{gemspec.version}"
-        @uncached_gemspecs.push gemspec
+        logger.debug { "Pins not yet cached for #{gemspec.name}:#{gemspec.version}" }
+        return nil
       end
     end
 
     # @param path [String] require path that might be in the RBS stdlib collection
     # @return [void]
-    def try_stdlib_map path
+    def deserialize_stdlib_rbs_map path
       map = RbsMap::StdlibMap.load(path)
       if map.resolved?
-        Solargraph.logger.debug "Loading stdlib pins for #{path}"
+        logger.debug { "Loading stdlib pins for #{path}" }
         @pins.concat map.pins
+        logger.debug { "Loaded #{map.pins.length} stdlib pins for #{path}" }
+        map.pins
       else
         # @todo Temporarily ignoring unresolved `require 'set'`
-        Solargraph.logger.debug "Require path #{path} could not be resolved" unless path == 'set'
+        logger.debug { "Require path #{path} could not be resolved in RBS" } unless path == 'set'
+        nil
+      end
+    end
+
+    # @return [Array<Pin::Base>, nil]
+    def deserialize_rbs_collection_cache gemspec, rbs_version_cache_key
+      return if rbs_collection_pins_in_memory.key?([gemspec, rbs_version_cache_key])
+      cached = PinCache.deserialize_rbs_collection_gem(gemspec, rbs_version_cache_key)
+      if cached
+        logger.info { "Loaded #{cached.length} pins from RBS collection cache for #{gemspec.name}:#{gemspec.version}" } unless cached.empty?
+        rbs_collection_pins_in_memory[[gemspec, rbs_version_cache_key]] = cached
+        cached
+      else
+        logger.debug "No RBS collection pin cache for #{gemspec.name} #{gemspec.version}"
+        @uncached_rbs_collection_gemspecs.push gemspec
+        nil
       end
     end
 
@@ -119,18 +284,6 @@ module Solargraph
       true
     end
 
-    # @param gemspec [Gem::Specification]
-    def update_from_collection gemspec, gempins
-      return gempins unless workspace&.rbs_collection_path && File.directory?(workspace&.rbs_collection_path)
-      return gempins if RbsMap.new(gemspec.name, gemspec.version).resolved?
-
-      rbs_map = RbsMap.new(gemspec.name, gemspec.version, directories: [workspace&.rbs_collection_path])
-      return gempins unless rbs_map.resolved?
-
-      Solargraph.logger.info "Updating #{gemspec.name} #{gemspec.version} from collection"
-      GemPins.combine(gempins, rbs_map)
-    end
-
     # @param path [String]
     # @return [::Array<Gem::Specification>, nil]
     def resolve_path_to_gemspecs path
@@ -149,7 +302,7 @@ module Solargraph
           file = "lib/#{path}.rb"
           gemspec = potential_gemspec if potential_gemspec.files.any? { |gemspec_file| file == gemspec_file }
         rescue Gem::MissingSpecError
-          Solargraph.logger.debug "Require path #{path} could not be resolved to a gem via find_by_path or guess of #{gem_name_guess}"
+          logger.debug { "Require path #{path} could not be resolved to a gem via find_by_path or guess of #{gem_name_guess}" }
           []
         end
       end
@@ -187,7 +340,7 @@ module Solargraph
         dep ||= Gem::Specification.find_by_name(spec.name, spec.requirement)
         deps.merge fetch_dependencies(dep) if deps.add?(dep)
       rescue Gem::MissingSpecError
-        Solargraph.logger.warn "Gem dependency #{spec.name} #{spec.requirement} for #{gemspec.name} not found."
+        Solargraph.logger.warn "Gem dependency #{spec.name} #{spec.requirement} for #{gemspec.name} not found in RubyGems."
       end.to_a
     end
 
@@ -197,8 +350,16 @@ module Solargraph
       gemspec.dependencies - gemspec.development_dependencies
     end
 
+
+    def inspect
+      self.class.inspect
+    end
+
     def gemspecs_required_from_bundler
-      if workspace&.directory && Bundler.definition&.lockfile&.to_s&.start_with?(workspace.directory)
+      # @todo Handle projects with custom Bundler/Gemfile setups
+      return unless workspace.gemfile?
+
+      if workspace.gemfile? && Bundler.definition&.lockfile&.to_s&.start_with?(workspace.directory)
         # Find only the gems bundler is now using
         Bundler.definition.locked_gems.specs.flat_map do |lazy_spec|
           logger.info "Handling #{lazy_spec.name}:#{lazy_spec.version}"
@@ -207,7 +368,7 @@ module Solargraph
           logger.info("Could not find #{lazy_spec.name}:#{lazy_spec.version} with find_by_name, falling back to guess")
           # can happen in local filesystem references
           specs = resolve_path_to_gemspecs lazy_spec.name
-          logger.info "Gem #{lazy_spec.name} #{lazy_spec.version} from bundle not found: #{e}" if specs.nil?
+          logger.warn "Gem #{lazy_spec.name} #{lazy_spec.version} from bundle not found: #{e}" if specs.nil?
           next specs
         end.compact
       else
@@ -229,18 +390,17 @@ module Solargraph
         if s.success?
           Solargraph.logger.debug "External bundle: #{o}"
           hash = o && !o.empty? ? JSON.parse(o.split("\n").last) : {}
-          hash.map do |name, version|
+          hash.flat_map do |name, version|
             Gem::Specification.find_by_name(name, version)
           rescue Gem::MissingSpecError => e
             logger.info("Could not find #{name}:#{version} with find_by_name, falling back to guess")
             # can happen in local filesystem references
             specs = resolve_path_to_gemspecs name
-            logger.info "Gem #{name} #{version} from bundle not found: #{e}" if specs.nil?
+            logger.warn "Gem #{name} #{version} from bundle not found: #{e}" if specs.nil?
             next specs
           end.compact
         else
-          Solargraph.logger.warn e
-          raise BundleNotFoundError, "Failed to load gems from bundle at #{workspace&.directory}"
+          Solargraph.logger.warn "Failed to load gems from bundle at #{workspace&.directory}: #{e}"
         end
       end
     end

data/lib/solargraph/gem_pins.rb

@@ -7,59 +7,75 @@ module Solargraph
   # documentation.
   #
   module GemPins
-    # Build an array of pins from a gem specification. The process starts with
-    # YARD, enhances the resulting pins with RBS definitions, and appends RBS
-    # pins that don't exist in the YARD mapping.
-    #
+    class << self
+      include Logging
+    end
+
     # @param gemspec [Gem::Specification]
     # @return [Array<Pin::Base>]
-    def self.build(gemspec)
-      yard_pins = build_yard_pins(gemspec)
-      rbs_map = RbsMap.from_gemspec(gemspec)
-      combine yard_pins, rbs_map
+    def self.build_yard_pins(gemspec)
+      Yardoc.cache(gemspec) unless Yardoc.cached?(gemspec)
+      yardoc = Yardoc.load!(gemspec)
+      YardMap::Mapper.new(yardoc, gemspec).map
+    end
+
+    # @param pins [Array<Pin::Base>]
+    def self.combine_method_pins_by_path(pins)
+      # bad_pins = pins.select { |pin| pin.is_a?(Pin::Method) && pin.path == 'StringIO.open' && pin.source == :rbs }; raise "wtf: #{bad_pins}" if bad_pins.length > 1
+      method_pins, alias_pins = pins.partition { |pin| pin.class == Pin::Method }
+      by_path = method_pins.group_by(&:path)
+      by_path.transform_values! do |pins|
+        GemPins.combine_method_pins(*pins)
+      end
+      by_path.values + alias_pins
+    end
+
+    def self.combine_method_pins(*pins)
+      out = pins.reduce(nil) do |memo, pin|
+        next pin if memo.nil?
+        if memo == pin && memo.source != :combined
+          # @todo we should track down situations where we are handled
+          #   the same pin from the same source here and eliminate them -
+          #   this is an efficiency workaround for now
+          next memo
+        end
+        memo.combine_with(pin)
+      end
+      logger.debug { "GemPins.combine_method_pins(pins.length=#{pins.length}, pins=#{pins}) => #{out.inspect}" }
+      out
     end
 
     # @param yard_pins [Array<Pin::Base>]
     # @param rbs_map [RbsMap]
     # @return [Array<Pin::Base>]
-    def self.combine(yard_pins, rbs_map)
+    def self.combine(yard_pins, rbs_pins)
       in_yard = Set.new
-      combined = yard_pins.map do |yard|
-        in_yard.add yard.path
-        next yard unless yard.is_a?(Pin::Method)
+      rbs_api_map = Solargraph::ApiMap.new(pins: rbs_pins)
+      combined = yard_pins.map do |yard_pin|
+        in_yard.add yard_pin.path
+        rbs_pin = rbs_api_map.get_path_pins(yard_pin.path).filter { |pin| pin.is_a? Pin::Method }.first
+        next yard_pin unless rbs_pin && yard_pin.class == Pin::Method
 
-        rbs = rbs_map.path_pin(yard.path, Pin::Method)
-        next yard unless rbs
+        unless rbs_pin
+          logger.debug { "GemPins.combine: No rbs pin for #{yard_pin.path} - using YARD's '#{yard_pin.inspect} (return_type=#{yard_pin.return_type}; signatures=#{yard_pin.signatures})" }
+          next yard_pin
+        end
 
-        # @sg-ignore
-        yard.class.new(
-          location: yard.location,
-          closure: yard.closure,
-          name: yard.name,
-          comments: yard.comments,
-          scope: yard.scope,
-          parameters: rbs.parameters,
-          generics: rbs.generics,
-          node: yard.node,
-          signatures: yard.signatures,
-          return_type: best_return_type(rbs.return_type, yard.return_type)
-        )
+        out = combine_method_pins(rbs_pin, yard_pin)
+        logger.debug { "GemPins.combine: Combining yard.path=#{yard_pin.path} - rbs=#{rbs_pin.inspect} with yard=#{yard_pin.inspect} into #{out}" }
+        out
       end
-      in_rbs = rbs_map.pins.reject { |pin| in_yard.include?(pin.path) }
-      combined + in_rbs
+      in_rbs_only = rbs_pins.select do |pin|
+        pin.path.nil? || !in_yard.include?(pin.path)
+      end
+      out = combined + in_rbs_only
+      logger.debug { "GemPins#combine: Returning #{out.length} combined pins" }
+      out
     end
 
     class << self
       private
 
-      # @param gemspec [Gem::Specification]
-      # @return [Array<Pin::Base>]
-      def build_yard_pins(gemspec)
-        Yardoc.cache(gemspec) unless Yardoc.cached?(gemspec)
-        yardoc = Yardoc.load!(gemspec)
-        YardMap::Mapper.new(yardoc, gemspec).map
-      end
-
       # Select the first defined type.
       #
       # @param choices [Array<ComplexType>]

data/lib/solargraph/language_server/host.rb

@@ -299,6 +299,10 @@ module Solargraph
         end
       end
 
+      def command_path
+        options['commandPath'] || 'solargraph'
+      end
+
       # Prepare multiple folders.
       #
       # @param array [Array<Hash{String => String}>]
@@ -501,7 +505,8 @@ module Solargraph
                 parameters: pin.parameters,
                 return_type: ComplexType.try_parse(params['data']['path']),
                 comments: pin.comments,
-                closure: pin.closure
+                closure: pin.closure,
+                source: :solargraph
               )
             end)
           end
@@ -597,7 +602,11 @@ module Solargraph
       # @return [Array]
       def document query
         result = []
-        libraries.each { |lib| result.concat lib.document(query) }
+        if libraries.empty?
+          result.concat generic_library.document(query)
+        else
+          libraries.each { |lib| result.concat lib.document(query) }
+        end
         result
       end
 

data/lib/solargraph/language_server/message/extended/check_gem_version.rb

@@ -83,6 +83,8 @@ module Solargraph
               @fetched = true
               begin
                 @available ||= begin
+                  # @sg-ignore
+                  # @type [Gem::Dependency, nil]
                   tuple = CheckGemVersion.fetcher.search_for_dependency(Gem::Dependency.new('solargraph')).flatten.first
                   if tuple.nil?
                     @error = 'An error occurred fetching the gem data'

data/lib/solargraph/language_server/message/extended/document.rb

@@ -6,12 +6,15 @@ module Solargraph
       module Extended
         class Document < Base
           def process
-            objects = host.document(params['query'])
+            api_map, pins = host.document(params['query'])
             page = Solargraph::Page.new(host.options['viewsPath'])
-            content = page.render('document', layout: true, locals: {objects: objects})
+            content = page.render('document', layout: true, locals: { api_map: api_map, pins: pins })
             set_result(
               content: content
             )
+          rescue StandardError => e
+            Solargraph.logger.warn "Error processing document: [#{e.class}] #{e.message}"
+            Solargraph.logger.debug e.backtrace.join("\n")
           end
         end
       end

data/lib/solargraph/language_server/message/extended/document_gems.rb

@@ -11,9 +11,9 @@ module Solargraph
         #
         class DocumentGems < Base
           def process
-            cmd = "yard gems"
-            cmd += " --rebuild" if params['rebuild']
-            o, s = Open3.capture2(cmd)
+            cmd = [host.command_path, 'gems']
+            cmd.push '--rebuild' if params['rebuild']
+            o, s = Open3.capture2(*cmd)
             if s != 0
               host.show_message "An error occurred while building gem documentation.", LanguageServer::MessageTypes::ERROR
               set_result({

data/lib/solargraph/library.rb

@@ -327,9 +327,10 @@ module Solargraph
 
     # @param query [String]
     # @return [Enumerable<YARD::CodeObjects::Base>]
+    # @return [Array(ApiMap, Enumerable<Pin::Base>)]
     def document query
       sync_catalog
-      mutex.synchronize { api_map.document query }
+      mutex.synchronize { [api_map, api_map.get_path_pins(query)] }
     end
 
     # @param query [String]
@@ -587,28 +588,53 @@ module Solargraph
     # @return [void]
     def cache_next_gemspec
       return if @cache_progress
-      spec = api_map.uncached_gemspecs.find { |spec| !cache_errors.include?(spec) }
+
+      spec = cacheable_specs.first
       return end_cache_progress unless spec
 
       pending = api_map.uncached_gemspecs.length - cache_errors.length - 1
-      logger.info "Caching #{spec.name} #{spec.version}"
-      Thread.new do
-        cache_pid = Process.spawn(workspace.command_path, 'cache', spec.name, spec.version.to_s)
-        report_cache_progress spec.name, pending
-        Process.wait(cache_pid)
-        logger.info "Cached #{spec.name} #{spec.version}"
-      rescue Errno::EINVAL => _e
-        logger.info "Cached #{spec.name} #{spec.version} with EINVAL"
-      rescue StandardError => e
-        cache_errors.add spec
-        Solargraph.logger.warn "Error caching gemspec #{spec.name} #{spec.version}: [#{e.class}] #{e.message}"
-      ensure
-        end_cache_progress
+
+      if Yardoc.processing?(spec)
+        logger.info "Enqueuing cache of #{spec.name} #{spec.version} (already being processed)"
+        queued_gemspec_cache.push(spec)
+        return if pending - queued_gemspec_cache.length < 1
+
         catalog
         sync_catalog
+      else
+        logger.info "Caching #{spec.name} #{spec.version}"
+        Thread.new do
+          cache_pid = Process.spawn(workspace.command_path, 'cache', spec.name, spec.version.to_s)
+          report_cache_progress spec.name, pending
+          Process.wait(cache_pid)
+          logger.info "Cached #{spec.name} #{spec.version}"
+        rescue Errno::EINVAL => _e
+          logger.info "Cached #{spec.name} #{spec.version} with EINVAL"
+        rescue StandardError => e
+          cache_errors.add spec
+          Solargraph.logger.warn "Error caching gemspec #{spec.name} #{spec.version}: [#{e.class}] #{e.message}"
+        ensure
+          end_cache_progress
+          catalog
+          sync_catalog
+        end
       end
     end
 
+    def cacheable_specs
+      cacheable = api_map.uncached_yard_gemspecs +
+                  api_map.uncached_rbs_collection_gemspecs -
+                  queued_gemspec_cache -
+                  cache_errors.to_a
+      return cacheable unless cacheable.empty?
+
+      queued_gemspec_cache
+    end
+
+    def queued_gemspec_cache
+      @queued_gemspec_cache ||= []
+    end
+
     # @param gem_name [String]
     # @param pending [Integer]
     # @return [void]
@@ -654,7 +680,8 @@ module Solargraph
         api_map.catalog bench
         source_map_hash.values.each { |map| find_external_requires(map) }
         logger.info "Catalog complete (#{api_map.source_maps.length} files, #{api_map.pins.length} pins)"
-        logger.info "#{api_map.uncached_gemspecs.length} uncached gemspecs"
+        logger.info "#{api_map.uncached_yard_gemspecs.length} uncached YARD gemspecs"
+        logger.info "#{api_map.uncached_rbs_collection_gemspecs.length} uncached RBS collection gemspecs"
         cache_next_gemspec
         @sync_count = 0
       end

data/lib/solargraph/location.rb

@@ -25,6 +25,19 @@ module Solargraph
       [filename, range]
     end
 
+    def <=>(other)
+      return nil unless other.is_a?(Location)
+      if filename == other.filename
+        range <=> other.range
+      else
+        filename <=> other.filename
+      end
+    end
+
+    def rbs?
+      filename.end_with?('.rbs')
+    end
+
     # @param location [self]
     def contain? location
       range.contain?(location.range.start) && range.contain?(location.range.ending) && filename == location.filename