solargraph 0.54.1 → 0.54.5

data/lib/solargraph/api_map.rb

@@ -12,6 +12,7 @@ module Solargraph
     autoload :Cache,          'solargraph/api_map/cache'
     autoload :SourceToYard,   'solargraph/api_map/source_to_yard'
     autoload :Store,          'solargraph/api_map/store'
+    autoload :Index,          'solargraph/api_map/index'
 
     # @return [Array<String>]
     attr_reader :unresolved_requires
@@ -48,6 +49,15 @@ module Solargraph
       equality_fields.hash
     end
 
+    def to_s
+      self.class.to_s
+    end
+
+    # avoid enormous dump
+    def inspect
+      to_s
+    end
+
     # @param pins [Array<Pin::Base>]
     # @return [self]
     def index pins
@@ -56,7 +66,7 @@ module Solargraph
       @source_map_hash = {}
       implicit.clear
       cache.clear
-      @store = Store.new(@@core_map.pins + pins)
+      store.update @@core_map.pins, pins
       self
     end
 
@@ -75,10 +85,9 @@ module Solargraph
     # @param bench [Bench]
     # @return [self]
     def catalog bench
-      old_api_hash = @source_map_hash&.values&.map(&:api_hash)
-      need_to_uncache = (old_api_hash != bench.source_maps.map(&:api_hash))
-      @source_map_hash = bench.source_maps.map { |s| [s.filename, s] }.to_h
-      pins = bench.source_maps.flat_map(&:pins).flatten
+      @source_map_hash = bench.source_map_hash
+      iced_pins = bench.icebox.flat_map(&:pins)
+      live_pins = bench.live_map&.pins || []
       implicit.clear
       source_map_hash.each_value do |map|
         implicit.merge map.environ
@@ -87,17 +96,17 @@ module Solargraph
       if @unresolved_requires != unresolved_requires || @doc_map&.uncached_gemspecs&.any?
         @doc_map = DocMap.new(unresolved_requires, [], bench.workspace.rbs_collection_path) # @todo Implement gem preferences
         @unresolved_requires = unresolved_requires
-        need_to_uncache = true
       end
-      @store = Store.new(@@core_map.pins + @doc_map.pins + implicit.pins + pins)
-      @cache.clear if need_to_uncache
-
+      @cache.clear if store.update(@@core_map.pins, @doc_map.pins, implicit.pins, iced_pins, live_pins)
       @missing_docs = [] # @todo Implement missing docs
       self
     end
 
+    # @todo need to model type def statement in chains as a symbol so
+    #   that this overload of 'protected' will typecheck @sg-ignore
+    # @sg-ignore
     protected def equality_fields
-      [self.class, @source_map_hash, implicit, @doc_map, @unresolved_requires, @missing_docs]
+      [self.class, @source_map_hash, implicit, @doc_map, @unresolved_requires]
     end
 
     # @return [::Array<Gem::Specification>]
@@ -183,7 +192,7 @@ module Solargraph
 
     # @return [Array<Solargraph::Pin::Base>]
     def pins
-      store.pins
+      store.pins.clone.freeze
     end
 
     # An array of pins based on Ruby keywords (`if`, `end`, etc.).
@@ -341,8 +350,12 @@ module Solargraph
     # @param deep [Boolean] True to include superclasses, mixins, etc.
     # @return [Array<Solargraph::Pin::Method>]
     def get_methods rooted_tag, scope: :instance, visibility: [:public], deep: true
+      rooted_type = ComplexType.try_parse(rooted_tag)
+      fqns = rooted_type.namespace
+      namespace_pin = store.get_path_pins(fqns).select { |p| p.is_a?(Pin::Namespace) }.first
       cached = cache.get_methods(rooted_tag, scope, visibility, deep)
       return cached.clone unless cached.nil?
+      # @type [Array<Solargraph::Pin::Method>]
       result = []
       skip = Set.new
       if rooted_tag == ''
@@ -380,9 +393,12 @@ module Solargraph
         result.concat inner_get_methods('Kernel', :instance, [:public], deep, skip) if visibility.include?(:private)
         result.concat inner_get_methods('Module', scope, visibility, deep, skip) if scope == :module
       end
-      resolved = resolve_method_aliases(result, visibility)
-      cache.set_methods(rooted_tag, scope, visibility, deep, resolved)
-      resolved
+      result = resolve_method_aliases(result, visibility)
+      if namespace_pin && rooted_tag != rooted_type.name
+        result = result.map { |method_pin| method_pin.resolve_generics(namespace_pin, rooted_type) }
+      end
+      cache.set_methods(rooted_tag, scope, visibility, deep, result)
+      result
     end
 
     # Get an array of method pins for a complex type.
@@ -438,8 +454,13 @@ module Solargraph
     # @param name [String] Method name to look up
     # @param scope [Symbol] :instance or :class
     # @return [Array<Solargraph::Pin::Method>]
-    def get_method_stack rooted_tag, name, scope: :instance
-      get_methods(rooted_tag, scope: scope, visibility: [:private, :protected, :public]).select { |p| p.name == name }
+    def get_method_stack rooted_tag, name, scope: :instance, visibility: [:private, :protected, :public], preserve_generics: false
+      rooted_type = ComplexType.parse(rooted_tag)
+      fqns = rooted_type.namespace
+      namespace_pin = store.get_path_pins(fqns).select { |p| p.is_a?(Pin::Namespace) }.first
+      methods = get_methods(rooted_tag, scope: scope, visibility: visibility).select { |p| p.name == name }
+      methods = erase_generics(namespace_pin, rooted_type, methods) unless preserve_generics
+      methods
     end
 
     # Get an array of all suggestions that match the specified path.
@@ -601,6 +622,7 @@ module Solargraph
       rooted_type = ComplexType.parse(rooted_tag).force_rooted
       fqns = rooted_type.namespace
       fqns_generic_params = rooted_type.all_params
+      namespace_pin = store.get_path_pins(fqns).select { |p| p.is_a?(Pin::Namespace) }.first
       return [] if no_core && fqns =~ /^(Object|BasicObject|Class|Module)$/
       reqstr = "#{fqns}|#{scope}|#{visibility.sort}|#{deep}"
       return [] if skip.include?(reqstr)
@@ -615,15 +637,7 @@ module Solargraph
       # Store#get_methods doesn't know about full tags, just
       # namespaces; resolving the generics in the method pins is this
       # class' responsibility
-      raw_methods = store.get_methods(fqns, scope: scope, visibility: visibility).sort{ |a, b| a.name <=> b.name }
-      namespace_pin = store.get_path_pins(fqns).select { |p| p.is_a?(Pin::Namespace) }.first
-      methods = if namespace_pin && rooted_tag != fqns
-                  methods = raw_methods.map do |method_pin|
-                    method_pin.resolve_generics(namespace_pin, rooted_type)
-                  end
-                else
-                  raw_methods
-                end
+      methods = store.get_methods(fqns, scope: scope, visibility: visibility).sort{ |a, b| a.name <=> b.name }
       result.concat methods
       if deep
         if scope == :instance
@@ -768,8 +782,8 @@ module Solargraph
 
     # Sort an array of pins to put nil or undefined variables last.
     #
-    # @param pins [Enumerable<Solargraph::Pin::Base>]
-    # @return [Enumerable<Solargraph::Pin::Base>]
+    # @param pins [Enumerable<Pin::BaseVariable>]
+    # @return [Enumerable<Pin::BaseVariable>]
     def prefer_non_nil_variables pins
       result = []
       nil_pins = []
@@ -809,11 +823,48 @@ module Solargraph
         name: pin.name,
         comments: origin.comments,
         scope: origin.scope,
+#        context: pin.context,
         visibility: origin.visibility,
         signatures: origin.signatures,
-        attribute: origin.attribute?
+        attribute: origin.attribute?,
+        generics: origin.generics,
+        return_type: origin.return_type,
       }
       Pin::Method.new **args
     end
+
+    include Logging
+
+    private
+
+    # @param namespace_pin [Pin::Namespace]
+    # @param rooted_type [ComplexType]
+    # @param pins [Enumerable<Pin::Base>]
+    # @return [Array<Pin::Base>]
+    def erase_generics(namespace_pin, rooted_type, pins)
+      return pins unless should_erase_generics_when_done?(namespace_pin, rooted_type)
+
+      logger.debug("Erasing generics on namespace_pin=#{namespace_pin} / rooted_type=#{rooted_type}")
+      pins.map do |method_pin|
+        method_pin.erase_generics(namespace_pin.generics)
+      end
+    end
+
+    # @param namespace_pin [Pin::Namespace]
+    # @param rooted_type [ComplexType]
+    def should_erase_generics_when_done?(namespace_pin, rooted_type)
+      has_generics?(namespace_pin) && !can_resolve_generics?(namespace_pin, rooted_type)
+    end
+
+    # @param namespace_pin [Pin::Namespace]
+    def has_generics?(namespace_pin)
+      namespace_pin && !namespace_pin.generics.empty?
+    end
+
+    # @param namespace_pin [Pin::Namespace]
+    # @param rooted_type [ComplexType]
+    def can_resolve_generics?(namespace_pin, rooted_type)
+      has_generics?(namespace_pin) && !rooted_type.all_params.empty?
+    end
   end
 end

data/lib/solargraph/bench.rb

@@ -11,18 +11,34 @@ module Solargraph
     # @return [Workspace]
     attr_reader :workspace
 
+    # @return [SourceMap]
+    attr_reader :live_map
+
     # @return [Set<String>]
     attr_reader :external_requires
 
     # @param source_maps [Array<SourceMap>, Set<SourceMap>]
     # @param workspace [Workspace]
+    # @param live_map [SourceMap, nil]
     # @param external_requires [Array<String>, Set<String>]
-    def initialize source_maps: [], workspace: Workspace.new, external_requires: []
+    def initialize source_maps: [], workspace: Workspace.new, live_map: nil, external_requires: []
       @source_maps = source_maps.to_set
       @workspace = workspace
+      @live_map = live_map
       @external_requires = external_requires.reject { |path| workspace.would_require?(path) }
                                             .compact
                                             .to_set
     end
+
+    # @return [Hash{String => SourceMap}]
+    def source_map_hash
+      # @todo Work around #to_h bug in current Ruby head (3.5) with #map#to_h
+      @source_map_hash ||= source_maps.map { |s| [s.filename, s] }
+                                      .to_h
+    end
+
+    def icebox
+      @icebox ||= (source_maps - [live_map])
+    end
   end
 end

data/lib/solargraph/complex_type/type_methods.rb

@@ -129,6 +129,13 @@ module Solargraph
         end.call
       end
 
+      def namespace_type
+        return ComplexType.parse('::Object') if duck_type?
+        return ComplexType.parse('::NilClass') if nil_type?
+        return subtypes.first if (name == 'Class' || name == 'Module') && !subtypes.empty?
+        self
+      end
+
       # @return [String]
       def rooted_namespace
         return namespace unless rooted? && can_root_name?(namespace)

data/lib/solargraph/complex_type/unique_type.rb

@@ -7,9 +7,15 @@ module Solargraph
     #
     class UniqueType
       include TypeMethods
+      include Equality
 
       attr_reader :all_params, :subtypes, :key_types
 
+      # @sg-ignore Fix "Not enough arguments to Module#protected"
+      protected def equality_fields
+        [@name, @all_params, @subtypes, @key_types]
+      end
+
       # 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
@@ -112,6 +118,10 @@ module Solargraph
         end
       end
 
+      def desc
+        rooted_tags
+      end
+
       # @return [String]
       def to_rbs
         if duck_type?
@@ -235,7 +245,17 @@ module Solargraph
           if t.name == GENERIC_TAG_NAME
             idx = definitions.generics.index(t.subtypes.first&.name)
             next t if idx.nil?
-            context_type.all_params[idx] || ComplexType::UNDEFINED
+            if context_type.parameters_type == :hash
+              if idx == 0
+                next ComplexType.new(context_type.key_types)
+              elsif idx == 1
+                next ComplexType.new(context_type.subtypes)
+              else
+                next ComplexType::UNDEFINED
+              end
+            else
+              context_type.all_params[idx] || ComplexType::UNDEFINED
+            end
           else
             t
           end

data/lib/solargraph/complex_type.rb

@@ -7,6 +7,7 @@ module Solargraph
     GENERIC_TAG_NAME = 'generic'.freeze
     # @!parse
     #   include TypeMethods
+    include Equality
 
     autoload :TypeMethods, 'solargraph/complex_type/type_methods'
     autoload :UniqueType,  'solargraph/complex_type/unique_type'
@@ -18,17 +19,9 @@ module Solargraph
       @items = types.flat_map(&:items).uniq(&:to_s)
     end
 
-    def eql?(other)
-      self.class == other.class &&
-        @items == other.items
-    end
-
-    def ==(other)
-      self.eql?(other)
-    end
-
-    def hash
-      [self.class, @items].hash
+    # @sg-ignore Fix "Not enough arguments to Module#protected"
+    protected def equality_fields
+      [self.class, items]
     end
 
     # @param api_map [ApiMap]
@@ -154,14 +147,22 @@ module Solargraph
       map(&:tag).join(', ')
     end
 
+    def desc
+      rooted_tags
+    end
+
     def rooted_tags
       map(&:rooted_tag).join(', ')
     end
 
+    # @yieldparam [UniqueType]
     def all? &block
       @items.all? &block
     end
 
+    # @yieldparam [UniqueType]
+    # @yieldreturn [Boolean]
+    # @return [Boolean]
     def any? &block
       @items.compact.any? &block
     end
@@ -263,7 +264,7 @@ module Solargraph
       #   Consumers should not need to use this parameter; it should only be
       #   used internally.
       #
-      # @param *strings [Array<String>] The type definitions to parse
+      # @param strings [Array<String>] The type definitions to parse
       # @return [ComplexType]
       # # @overload parse(*strings, partial: false)
       # #  @todo Need ability to use a literal true as a type below

data/lib/solargraph/convention.rb

@@ -11,6 +11,7 @@ module Solargraph
     autoload :Gemspec, 'solargraph/convention/gemspec'
     autoload :Rakefile, 'solargraph/convention/rakefile'
 
+    # @type [Set<Convention::Base>]
     @@conventions = Set.new
 
     # @param convention [Class<Convention::Base>]

data/lib/solargraph/doc_map.rb

@@ -112,6 +112,7 @@ module Solargraph
       true
     end
 
+    # @param gemspec [Gem::Specification]
     def update_from_collection gemspec, gempins
       return gempins unless @rbs_path && File.directory?(@rbs_path)
       return gempins if RbsMap.new(gemspec.name, gemspec.version).resolved?

data/lib/solargraph/equality.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Solargraph
+  # @abstract This mixin relies on these -
+  #   methods:
+  #     equality_fields()
+  module Equality
+    # @!method equality_fields
+    #   @return [Array]
+
+    # @param other [Object]
+    # @return [Boolean]
+    def eql?(other)
+      self.class.eql?(other.class) &&
+        equality_fields.eql?(other.equality_fields)
+    end
+
+    # @param other [Object]
+    # @return [Boolean]
+    def ==(other)
+      self.eql?(other)
+    end
+
+    def hash
+      equality_fields.hash
+    end
+
+    def freeze
+      equality_fields.each(&:freeze)
+      super
+    end
+  end
+end

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

@@ -3,12 +3,14 @@
 module Solargraph
   module LanguageServer
     class Host
-      # A serial worker Thread to handle message.
-      #
-      # this make check pending message possible, and maybe cancelled to speedup process
+      # A serial worker Thread to handle incoming messages.
       #
       class MessageWorker
-        UPDATE_METHODS = ['textDocument/didOpen', 'textDocument/didChange', 'workspace/didChangeWatchedFiles'].freeze
+        UPDATE_METHODS = [
+          'textDocument/didOpen',
+          'textDocument/didChange',
+          'workspace/didChangeWatchedFiles'
+        ].freeze
 
         # @param host [Host]
         def initialize(host)
@@ -64,12 +66,24 @@ module Solargraph
         private
 
         def next_message
+          cancel_message || next_priority
+        end
+
+        def cancel_message
+          # Handle cancellations first
+          idx = messages.find_index { |msg| msg['method'] == '$/cancelRequest' }
+          return unless idx
+
+          msg = messages[idx]
+          messages.delete_at idx
+          msg
+        end
+
+        def next_priority
           # Prioritize updates and version-dependent messages for performance
           idx = messages.find_index do |msg|
             UPDATE_METHODS.include?(msg['method']) || version_dependent?(msg)
           end
-          # @todo We might want to clear duplicate instances of this message
-          #   that occur before the next update
           return messages.shift unless idx
 
           msg = messages[idx]
@@ -80,6 +94,9 @@ module Solargraph
         # True if the message requires a previous update to have executed in
         # order to work correctly.
         #
+        # @param msg [Hash{String => Object}]
+        # @todo need boolish type from RBS
+        # @return [Object]
         def version_dependent? msg
           msg['textDocument'] && msg['position']
         end

data/lib/solargraph/language_server/host.rb

@@ -24,10 +24,8 @@ module Solargraph
       attr_writer :client_capabilities
 
       def initialize
-        @cancel_semaphore = Mutex.new
         @buffer_semaphore = Mutex.new
         @request_mutex = Mutex.new
-        @cancel = []
         @buffer = String.new
         @stopped = true
         @next_request_id = 1
@@ -65,7 +63,7 @@ module Solargraph
       # @param id [Integer]
       # @return [void]
       def cancel id
-        @cancel_semaphore.synchronize { @cancel.push id }
+        cancelled.push id
       end
 
       # True if the host received a request to cancel the method with the
@@ -74,9 +72,7 @@ module Solargraph
       # @param id [Integer]
       # @return [Boolean]
       def cancel? id
-        result = false
-        @cancel_semaphore.synchronize { result = @cancel.include? id }
-        result
+        cancelled.include? id
       end
 
       # Delete the specified ID from the list of cancelled IDs if it exists.
@@ -84,7 +80,7 @@ module Solargraph
       # @param id [Integer]
       # @return [void]
       def clear id
-        @cancel_semaphore.synchronize { @cancel.delete id }
+        cancelled.delete id
       end
 
       # Called by adapter, to handle the request
@@ -101,11 +97,11 @@ module Solargraph
       # @return [Solargraph::LanguageServer::Message::Base, nil] The message handler.
       def receive request
         if request['method']
-          logger.info "Server received #{request['method']}"
+          logger.info "Host received ##{request['id']} #{request['method']}"
           logger.debug request
           message = Message.select(request['method']).new(self, request)
           begin
-            message.process
+            message.process unless cancel?(request['id'])
           rescue StandardError => e
             logger.warn "Error processing request: [#{e.class}] #{e.message}"
             logger.warn e.backtrace.join("\n")
@@ -381,7 +377,6 @@ module Solargraph
           envelope = "Content-Length: #{json.bytesize}\r\n\r\n#{json}"
           queue envelope
           @next_request_id += 1
-          logger.info "Server sent #{method}"
           logger.debug params
         end
       end
@@ -476,6 +471,7 @@ module Solargraph
       def locate_pins params
         return [] unless params['data'] && params['data']['uri']
         library = library_for(params['data']['uri'])
+        # @type [Array<Pin::Base>]
         result = []
         if params['data']['location']
           location = Location.new(
@@ -575,7 +571,7 @@ module Solargraph
       # @param column [Integer]
       # @param strip [Boolean] Strip special characters from variable names
       # @param only [Boolean] If true, search current file only
-      # @return [Array<Solargraph::Range>]
+      # @return [Array<Solargraph::Location>]
       def references_from uri, line, column, strip: true, only: false
         library = library_for(uri)
         library.references_from(uri_to_file(uri), line, column, strip: strip, only: only)
@@ -693,6 +689,11 @@ module Solargraph
 
       private
 
+      # @return [Array<Integer>]
+      def cancelled
+        @cancelled ||= []
+      end
+
       # @return [MessageWorker]
       def message_worker
         @message_worker ||= MessageWorker.new(self)

data/lib/solargraph/language_server/message/base.rb

@@ -16,7 +16,7 @@ module Solargraph
         # @return [String]
         attr_reader :method
 
-        # @return [Hash{String => Array, Hash, String, Integer}]
+        # @return [Hash{String => Array<undefined>, Hash{String => undefined}, String, Integer}]
         attr_reader :params
 
         # @return [Hash, Array, nil]
@@ -61,18 +61,11 @@ module Solargraph
         # @return [void]
         def send_response
           return if id.nil?
-          if host.cancel?(id)
-            # https://microsoft.github.io/language-server-protocol/specifications/specification-current/#cancelRequest
-            # cancel should send response RequestCancelled
-            Solargraph::Logging.logger.info "Cancelled response to #{method}"
-            set_result nil
-            set_error ErrorCodes::REQUEST_CANCELLED, "cancelled by client"
-          else
-            Solargraph::Logging.logger.info "Sending response to #{method}"
-          end
+
+          accept_or_cancel
           response = {
-            jsonrpc: "2.0",
-            id: id,
+            jsonrpc: '2.0',
+            id: id
           }
           response[:result] = result unless result.nil?
           response[:error] = error unless error.nil?
@@ -83,6 +76,20 @@ module Solargraph
           host.queue envelope
           host.clear id
         end
+
+        private
+
+        def accept_or_cancel
+          if host.cancel?(id)
+            # https://microsoft.github.io/language-server-protocol/specifications/specification-current/#cancelRequest
+            # cancel should send response RequestCancelled
+            Solargraph::Logging.logger.info "Cancelled response to ##{id} #{method}"
+            set_result nil
+            set_error ErrorCodes::REQUEST_CANCELLED, 'Cancelled by client'
+          else
+            Solargraph::Logging.logger.info "Sending response to ##{id} #{method}"
+          end
+        end
       end
     end
   end

data/lib/solargraph/language_server/message/initialize.rb

@@ -174,7 +174,9 @@ module Solargraph
 
         # @param section [String]
         # @param capability [String]
-        # @return [Boolean]
+        # @todo Need support for RBS' boolish "type", which doesn't
+        #   enforce strict true/false-ness
+        # @sg-ignore
         def dynamic_registration_for? section, capability
           result = (params['capabilities'] &&
             params['capabilities'][section] &&

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

@@ -12,9 +12,6 @@ module Solargraph
             col = params['position']['character']
             begin
               completion = host.completions_at(params['textDocument']['uri'], line, col)
-              if host.cancel?(id)
-                return set_result(empty_result) if host.cancel?(id)
-              end
               items = []
               last_context = nil
               idx = -1

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

@@ -33,6 +33,7 @@ module Solargraph
 
           private
 
+          # @param corrections [String]
           def log_corrections(corrections)
             corrections = corrections&.strip
             return if corrections&.empty?
@@ -51,6 +52,7 @@ module Solargraph
             conf['rubocop'] || {}
           end
 
+          # @param config [Hash{String => String}]
           def cli_args file_uri, config
             file = UriHelpers.uri_to_file(file_uri)
             args = [
@@ -68,6 +70,7 @@ module Solargraph
             args + [file]
           end
 
+          # @param config [Hash{String => String}]
           def formatter_class(config)
             if self.class.const_defined?('BlankRubocopFormatter')
               # @sg-ignore
@@ -79,6 +82,7 @@ module Solargraph
             end
           end
 
+          # @param value [Array, String]
           def cop_list(value)
             value = value.join(',') if value.respond_to?(:join)
             return nil if value == '' || !value.is_a?(String)