solargraph 0.60.4 → 0.62.0

data/lib/solargraph/cache_dir.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'rbs'
+
+module Solargraph
+  module CacheDir
+    module_function
+
+    # The base directory for cached YARD documentation and serialized pins.
+    #
+    # @return [String]
+    def base_dir
+      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
+      File.join(base_dir, "ruby-#{RUBY_VERSION}", "rbs-#{RBS::VERSION}", "solargraph-#{Solargraph::VERSION}")
+    end
+
+    # The current gem directory.
+    #
+    # @return [String]
+    def gem_dir
+      File.join(work_dir, 'gems')
+    end
+
+    # The current stdlib directory.
+    #
+    # @return [String]
+    def stdlib_dir
+      File.join(work_dir, 'stdlib')
+    end
+
+    # The current RBS collection directory.
+    #
+    # @return [String]
+    def rbs_dir
+      File.join(work_dir, 'rbs')
+    end
+
+    # The directory for the current YARD version.
+    #
+    # @return [String]
+    def yard_dir
+      File.join(base_dir, "yard-#{YARD::VERSION}", "yard-activesupport-concern-#{YARD::ActiveSupport::Concern::VERSION}")
+    end
+
+    def clear
+      FileUtils.rm_rf base_dir
+    end
+  end
+end

data/lib/solargraph/collection/base.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+
+module Solargraph
+  module Collection
+    # The base class for cacheable pin collections. Subclasses need to
+    # implement #pins and #cache_file.
+    #
+    # @!method pins
+    #   The array of pins for this collection.
+    #   @abstract
+    #   @return [Array<Pin::Base>]
+    # @!method cache_file
+    #   The file that will store serialized pins.
+    #   @abstract
+    #   @return [String]
+    class Base
+      # @return [Array<Pin::Base>]
+      def load
+        Collection.cached(cache_file) { file_cache_pins || generate_pin_caches }
+      end
+
+      # @return [Array<Pin::Base>]
+      def self.load(...)
+        new(...).load
+      end
+
+      def self.uncache(...)
+        cache_file = new(...).cache_file
+        FileUtils.rm_rf cache_file
+        Collection.mem_cache.delete cache_file
+      end
+
+      private
+
+      def file_cache_pins
+        Marshal.load(File.read(cache_file, mode: 'rb')) if File.exist?(cache_file) # rubocop:disable Security/MarshalLoad
+      end
+
+      def generate_pin_caches
+        Collection.mem_cache[cache_file] = pins
+        serial = Marshal.dump(pins)
+        FileUtils.mkdir_p File.dirname(cache_file)
+        File.write cache_file, serial, mode: 'wb'
+        pins
+      end
+    end
+  end
+end

data/lib/solargraph/collection/core.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Collection
+    # Cacheable core pins.
+    #
+    class Core < Base
+      def cache_file
+        File.join CacheDir.work_dir, 'core.ser'
+      end
+
+      def pins
+        @pins ||= RbsMap::Core.pins
+      end
+    end
+  end
+end

data/lib/solargraph/collection/gem.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Collection
+    # Cacheable gem pins.
+    #
+    class Gem < Base
+      include Logging
+
+      attr_reader :metagem
+
+      @@path_source_cache = {}
+
+      # @param metagem [Metagem]
+      def initialize metagem
+        super()
+        @metagem = metagem
+      end
+
+      def cache_file
+        File.join CacheDir.gem_dir, "#{metagem.cache_name}.ser"
+      end
+
+      def load
+        return super if metagem.cacheable?
+        @@path_source_cache[metagem.full_path] ||= pins
+      end
+
+      def pins
+        @pins ||= without_yard
+      end
+
+      def self.cached? metagem
+        metagem.cacheable? && File.exist?(new(metagem).cache_file)
+      end
+
+      private
+
+      def with_yard
+        code_objects = Yardoc.load!(metagem)
+        yard_pins = YardMap::Mapper.new(code_objects, metagem).map
+        rbs_pins = RbsMap::Gem.pins(metagem)
+        RbsMap::Helpers.combine(yard_pins, rbs_pins)
+      end
+
+      def without_yard
+        files = metagem.require_paths.flat_map { |path| Dir.glob(File.join(metagem.full_path, path, '**', '*.rb')) }
+        source_maps = files.map { |file| Solargraph::SourceMap.load(file) }
+
+        # Generating an ApiMap is necessary for processing macros
+        bench = Bench.new(source_maps: source_maps)
+        source_pins = ApiMap.new.catalog(bench).pins.select { |pin| files.include?(pin.filename) }
+
+        rbs_pins = RbsMap::Gem.pins(metagem)
+        RbsMap::Helpers.combine(source_pins, rbs_pins)
+      end
+    end
+  end
+end

data/lib/solargraph/collection/stdlib.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Collection
+    # Cacheable stdlib pins.
+    #
+    class Stdlib < Base
+      attr_reader :library
+
+      # @param library [String]
+      def initialize library
+        super()
+        @library = library
+      end
+
+      def pins
+        @pins ||= RbsMap::Stdlib.pins(library)
+      end
+
+      def cache_file
+        File.join CacheDir.stdlib_dir, "#{library}.ser"
+      end
+    end
+  end
+end

data/lib/solargraph/collection.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Collection
+    autoload :Base,   'solargraph/collection/base'
+    autoload :Core,   'solargraph/collection/core'
+    autoload :Gem,    'solargraph/collection/gem'
+    autoload :Stdlib, 'solargraph/collection/stdlib'
+
+    # A hash for storing pin collections in memory.
+    #
+    # @return [Hash{String => Array<Pin::Base>}]
+    def self.mem_cache
+      @mem_cache ||= {}
+    end
+
+    # The pins cached under a key, storing the block result on a miss.
+    #
+    # @param key [String]
+    # @return [Array<Pin::Base>]
+    def self.cached key
+      mem_cache.fetch(key) { mem_cache[key] = yield }
+    end
+
+    # @return [void]
+    def self.clear_mem_cache
+      mem_cache.clear
+    end
+  end
+end

data/lib/solargraph/complex_type/unique_type.rb

@@ -11,6 +11,13 @@ module Solargraph
 
       attr_reader :all_params, :subtypes, :key_types
 
+      # @type [Hash{String => String}]
+      ANONYMOUS_NAME_BY_STARTING_TAG = {
+        '{' => 'Hash',
+        '(' => 'Array',
+        '<' => 'Array'
+      }.freeze
+
       # Create a UniqueType with the specified name and an optional substring.
       # The substring is the parameter section of a parametrized type, e.g.,
       # for the type `Array<String>`, the name is `Array` and the substring is
@@ -22,6 +29,9 @@ module Solargraph
       # @return [UniqueType]
       def self.parse name, substring = '', make_rooted: nil
         raise ComplexTypeError, "Illegal prefix: #{name}" if name.start_with?(':::')
+        # Anonymous shorthand (`<A>`, `(A)`, `{A=>B}`) defaults the
+        # omitted type name to Array or Hash, before the rooted check below.
+        name = ANONYMOUS_NAME_BY_STARTING_TAG.fetch(substring.chars.fetch(0)) if name.empty? && !substring.empty?
         if name.start_with?('::')
           name = name[2..]
           rooted = true
@@ -443,6 +453,9 @@ module Solargraph
       # @param context_type [ComplexType] The receiver type
       # @return [UniqueType, ComplexType]
       def resolve_generics definitions, context_type
+        # Method-scoped generics bind per call site via
+        # resolve_generics_from_context, not against a receiver's type params.
+        return self if definitions.is_a?(Pin::Callable)
         return self if definitions.nil? || definitions.generics.empty?
 
         transform(name) do |t|

data/lib/solargraph/complex_type.rb

@@ -50,9 +50,10 @@ module Solargraph
     def resolve_generics_from_context generics_to_resolve, context_type, resolved_generic_values: {}
       return self unless generic?
 
-      ComplexType.new(@items.map do |i|
-        i.resolve_generics_from_context(generics_to_resolve, context_type,
-                                        resolved_generic_values: resolved_generic_values)
+      ComplexType.new(@items.map do |unique_type|
+        unique_type.resolve_generics_from_context(generics_to_resolve,
+                                                  destructure_context_type(unique_type, context_type),
+                                                  resolved_generic_values: resolved_generic_values)
       end)
     end
 
@@ -561,6 +562,25 @@ module Solargraph
 
     private
 
+    # Narrows what a generic member binds against: context members this type
+    # already matches concretely are dropped. Nothing left over means no value
+    # can reach the generic, which is bot.
+    #
+    # @param unique_type [UniqueType] A member of @items
+    # @param context_type [ComplexType, UniqueType, nil]
+    # @return [ComplexType, UniqueType, nil]
+    def destructure_context_type unique_type, context_type
+      return context_type unless unique_type.generic? && context_type.is_a?(ComplexType) && @items.length > 1
+
+      concrete_items = @items.reject(&:generic?)
+      return context_type if concrete_items.empty?
+
+      remaining_items = context_type.items.reject { |ct| concrete_items.any? { |ci| ci.name == ct.name } }
+      return BOT if remaining_items.empty?
+
+      ComplexType.new(remaining_items)
+    end
+
     # @todo This is a quick and dirty hack that forces `self` keywords
     #   to reference an instance of their class and never the class itself.
     #   This behavior may change depending on which result is expected

data/lib/solargraph/convention.rb

@@ -9,9 +9,6 @@ module Solargraph
     autoload :Gemfile, 'solargraph/convention/gemfile'
     autoload :Gemspec, 'solargraph/convention/gemspec'
     autoload :Rakefile, 'solargraph/convention/rakefile'
-    autoload :StructDefinition, 'solargraph/convention/struct_definition'
-    autoload :DataDefinition,   'solargraph/convention/data_definition'
-    autoload :ActiveSupportConcern, 'solargraph/convention/active_support_concern'
 
     # @type [Set<Convention::Base>]
     @@conventions = Set.new
@@ -38,12 +35,14 @@ module Solargraph
       result
     end
 
-    # @param doc_map [DocMap]
+    # @todo Determine what argument needs to be passed here
+    #
+    # @param object [Object]
     # @return [Environ]
-    def self.for_global doc_map
+    def self.for_global object
       result = Environ.new
       @@conventions.each do |conv|
-        result.merge conv.global(doc_map)
+        result.merge conv.global(object)
       end
       result
     end
@@ -73,6 +72,5 @@ module Solargraph
     register Gemfile
     register Gemspec
     register Rakefile
-    register ActiveSupportConcern
   end
 end

data/lib/solargraph/diagnostics/require_not_found.rb

@@ -13,10 +13,6 @@ module Solargraph
         # @sg-ignore Need to add nil check here
         map = api_map.source_map(source.filename)
         map.requires.each { |ref| refs[ref.name] = ref }
-        api_map.missing_docs.each do |r|
-          next unless refs.key?(r)
-          result.push docs_error(r, refs[r].location)
-        end
         api_map.unresolved_requires.each do |r|
           next unless refs.key?(r)
           result.push require_error(r, refs[r].location)

data/lib/solargraph/diagnostics/type_check.rb

@@ -11,7 +11,6 @@ module Solargraph
         # return [] unless args.include?('always') || api_map.workspaced?(source.filename)
         severity = Diagnostics::Severities::ERROR
         level = args.reverse.find { |a| %w[normal typed strict strong].include?(a) } || :normal
-        # @sg-ignore sensitive typing needs to handle || on nil types
         checker = Solargraph::TypeChecker.new(source.filename, api_map: api_map, level: level.to_sym)
         checker.problems
                .sort { |a, b| a.location.range.start.line <=> b.location.range.start.line }

data/lib/solargraph/external.rb

@@ -0,0 +1,187 @@
+# frozen_string_literal: true
+
+require 'set'
+
+module Solargraph
+  # @todo This class might need a way to track changes to the repo, e.g.,
+  #   bundle or dependency updates
+  #
+  class External
+    # @return [String]
+    attr_reader :directory
+
+    # @return [Array<String>]
+    attr_reader :requires
+
+    attr_reader :extra_gem_names
+
+    # @param directory [String]
+    # @param requires [Array<String>]
+    # @param extra_gem_names [Array<String>]
+    def initialize directory, requires, extra_gem_names = []
+      @repo = Repo.new(directory)
+      @directory = directory
+      @requires = requires
+      @extra_gem_names = extra_gem_names
+      update!
+    end
+
+    def configured_gem_names
+      loaded_gems.map(&:name) + unloaded_gems.map(&:name) + extra_gem_names
+    end
+
+    def unresolved_requires
+      @unresolved_requires ||= []
+    end
+
+    def unresolved_dependencies
+      @unresolved_dependencies ||= []
+    end
+
+    def loaded_gems
+      @loaded_gems ||= Set.new
+    end
+
+    def unloaded_gems
+      @unloaded_gems ||= Set.new
+    end
+
+    def unfound_gem_names
+      @unfound_gem_names ||= []
+    end
+
+    def loaded_stdlibs
+      @loaded_stdlibs ||= Set.new
+    end
+
+    def pins
+      @pins ||= []
+    end
+
+    # @return [Integer] incremented whenever the external pin set is rebuilt
+    def generation
+      @generation ||= 0
+    end
+
+    # @param new_requires [Array<String>]
+    # @return [Boolean]
+    def update new_requires, new_gem_names = []
+      return false if requires == new_requires && new_gem_names == extra_gem_names && !cache_changed?
+
+      requires.replace new_requires
+      extra_gem_names.replace new_gem_names
+      update!
+      true
+    end
+
+    # @return [Array<String>]
+    def rbs_collection_paths
+      @rbs_collection_paths ||= read_rbs_collection_paths
+    end
+
+    # @return [String, nil]
+    def rbs_collection_config_path
+      # @todo Get rid of the '*' case
+      @rbs_collection_config_path ||= unless directory.nil? || directory.empty? || directory == '*'
+                                        yaml_file = File.join(directory, 'rbs_collection.yaml')
+                                        yaml_file if File.file?(yaml_file)
+                                      end
+    end
+
+    private
+
+    def update!
+      @generation = generation + 1
+      clear_all
+      load_requires
+      load_gem_names
+      # load_rbs_collection
+    end
+
+    def cache_changed?
+      unloaded_gems.any? { |gem| Collection::Gem.cached?(gem) }
+    end
+
+    def load_requires
+      bundler_require = false
+
+      requires.uniq.each do |path|
+        if path == 'bundler/require'
+          bundler_require = true
+        end
+        if RbsMap::Stdlib.has?(path)
+          pins.concat Collection::Stdlib.load(path) if loaded_stdlibs.add?(path)
+        else
+          metagem = @repo.find_by_path(path)
+          next unresolved_requires.push(path) unless metagem
+          process_gem metagem
+        end
+      end
+
+      return unless bundler_require
+
+      @repo.find_by_group(:default).each { |metagem| process_gem metagem }
+    end
+
+    def load_gem_names
+      extra_gem_names.uniq.each do |gem|
+        metagem = @repo.find_by_name(gem)
+        next unfound_gem_names.push(gem) unless metagem
+        process_gem metagem
+      end
+    end
+
+    def rbs_collection
+      @rbs_collection ||= RbsCollection.new(rbs_collection_lockfile)
+    end
+
+    def rbs_collection_lockfile
+      return if directory.nil? || directory.empty? || directory == '*'
+      lockfile = File.join(directory, 'rbs_collection.lock.yaml')
+      lockfile if File.file?(lockfile)
+    end
+
+    def clear_all
+      pins.clear
+      unresolved_requires.clear
+      unresolved_dependencies.clear
+      loaded_gems.clear
+      unloaded_gems.clear
+      loaded_stdlibs.clear
+      unfound_gem_names.clear
+    end
+
+    def process_gem metagem
+      return if loaded_gems.include?(metagem) || unloaded_gems.include?(metagem)
+
+      if metagem.cacheable? && !Collection::Gem.cached?(metagem)
+        unloaded_gems.add metagem
+      else
+        loaded_gems.add metagem
+        base_pins = Collection::Gem.load(metagem)
+        rbsc_pins = rbs_collection.load(metagem)
+        if rbsc_pins.empty?
+          pins.concat base_pins
+        else
+          pins.concat RbsMap::Helpers.combine(base_pins, rbsc_pins)
+        end
+        # Gems might not declare stdlib dependencies as gem dependencies
+        # (e.g., `activesupport` requires `date`)
+        base_pins.select { |pin| pin.is_a?(Pin::Reference::Require) && RbsMap::Stdlib.has?(pin.name) }
+                 .each do |pin|
+                   pins.concat Collection::Stdlib.load(pin.name) if loaded_stdlibs.add?(pin.name)
+                 end
+      end
+      load_dependencies metagem
+    end
+
+    def load_dependencies parent
+      parent.dependencies.each do |name|
+        next if loaded_gems.map(&:name).include?(name) || unloaded_gems.map(&:name).include?(name)
+        metagem = @repo.find_by_name(name)
+        next unresolved_dependencies.push(name) unless metagem
+        process_gem metagem
+      end
+    end
+  end
+end

data/lib/solargraph/language_server/host/diagnoser.rb

@@ -61,7 +61,7 @@ module Solargraph
             return
           end
           current = mutex.synchronize { queue.shift }
-          return if queue.include?(current)
+          return if current.nil? || queue.include?(current)
           begin
             host.diagnose current
           rescue InvalidOffsetError

data/lib/solargraph/language_server/host/dispatch.rb

@@ -118,11 +118,13 @@ module Solargraph
                                                   .tap { |lib| lib.add_observer self }
         end
 
-        # @param progress [Solargraph::LanguageServer::Progress, nil]
+        # The Library observer callback that #generic_library registers.
         #
+        # @abstract
+        # @param progress [Solargraph::LanguageServer::Progress, nil]
         # @return [void]
         def update progress
-          progress&.send(self)
+          raise NotImplementedError, 'Host::Dispatch requires an update method'
         end
       end
     end

data/lib/solargraph/language_server/host.rb

@@ -495,7 +495,7 @@ module Solargraph
           )
           result.concat(library.locate_pins(location).select { |pin| pin.name == params['label'] })
         end
-        if params['data']['path']
+        if params['data']['path'] && !params['data']['path'].empty?
           result.concat library.path_pins(params['data']['path'])
           # @todo This exception is necessary because `Library#path_pins` does
           #   not perform a namespace method query, so the implicit `.new` pin
@@ -706,6 +706,15 @@ module Solargraph
         client_capabilities['window'] && client_capabilities['window']['workDoneProgress']
       end
 
+      # The Library observer callback that sends a library's progress to
+      # the client.
+      #
+      # @param progress [Solargraph::LanguageServer::Progress, nil]
+      # @return [void]
+      def update progress
+        progress&.send(self)
+      end
+
       private
 
       # @return [Array<Integer>]
@@ -736,7 +745,6 @@ module Solargraph
       # @return [String]
       def normalize_separators path
         return path if File::ALT_SEPARATOR.nil?
-        # @sg-ignore flow sensitive typing needs to handle constants
         path.gsub(File::ALT_SEPARATOR, File::SEPARATOR)
       end
 

data/lib/solargraph/language_server/message/completion_item/resolve.rb

@@ -7,6 +7,12 @@ module Solargraph
         # completionItem/resolve message handler
         #
         class Resolve < Base
+          # Properties that must not be changed during completionItem/resolve
+          # according to the LSP specification.
+          #
+          # @see https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#textDocument_completion
+          IMMUTABLE_FIELDS = %i[label kind sortText filterText insertText textEdit data].freeze
+
           def process
             pins = host.locate_pins(params)
             set_result merge(pins)
@@ -17,14 +23,15 @@ module Solargraph
           # @param pins [Array<Pin::Base>]
           # @return [Hash]
           def merge pins
-            return params if pins.empty?
+            original = params.transform_keys(&:to_sym)
+            return original if pins.empty?
             docs = pins
                    .reject { |pin| pin.documentation.empty? && pin.return_type.undefined? }
-            result = params
-                     .transform_keys(&:to_sym)
+            result = original
                      .merge(pins.first.resolve_completion_item)
                      .merge(documentation: markup_content(join_docs(docs)))
             result[:detail] = pins.first.detail
+            IMMUTABLE_FIELDS.each { |field| result[field] = original[field] }
             result
           end
 

data/lib/solargraph/language_server/message/text_document/definition.rb

@@ -15,7 +15,7 @@ module Solargraph
 
           # @return [Array<Hash>, nil]
           def code_location
-            suggestions = host.definitions_at(params['textDocument']['uri'], @line, @column)
+            suggestions = host.definitions_at(params['textDocument']['uri'], @line, @column) || []
             # @sg-ignore Need to add nil check here
             return nil if suggestions.empty?
             # @sg-ignore Need to add nil check here
@@ -29,7 +29,10 @@ module Solargraph
 
           # @return [Array<Hash>, nil]
           def require_location
-            # @todo Terrible hack
+            # @todo Terrible hack - move this logic to [Solargraph::Source::Chain::Parameter]
+            #   @example
+            #     require 'click_me'
+            #             ^^^^^^^^^^
             lib = host.library_for(params['textDocument']['uri'])
             rloc = Solargraph::Location.new(uri_to_file(params['textDocument']['uri']),
                                             Solargraph::Range.from_to(@line, @column, @line, @column))

data/lib/solargraph/language_server/message/text_document/hover.rb

@@ -11,8 +11,7 @@ module Solargraph
             contents = []
             suggestions = host.definitions_at(params['textDocument']['uri'], line, col)
             last_link = nil
-            # @sg-ignore Need to add nil check here
-            suggestions.each do |pin|
+            suggestions&.each do |pin|
               parts = []
               this_link = host.options['enablePages'] ? pin.link_documentation : pin.text_documentation
               parts.push this_link if !this_link.nil? && this_link != last_link