solargraph 0.54.0 → 0.54.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 39ad27afe3afb59299f8701f9a7ea3f25a9f95379ef68e53ac0e22eb60f50e21
-  data.tar.gz: 1f01a9d5cdf4aec5b50c245a25b1f7d83e5d6762e5b8f65bc9ce3555654e21ed
+  metadata.gz: d6619265fc1ba2cab9154e70c5f4a6626999b685d58e26a805ec606d6804f17b
+  data.tar.gz: cfac32a13734ba9b392d27fcb8da7c76b180f0bf64189d17698b2246ce6e3773
 SHA512:
-  metadata.gz: 788f17e92a54e782ea1dcf03cb44245df823ba33b4fe866d1afa5d06c7171b40a4e1f93c97c8b26c13b58be7478b9b07cd75d6735da65ecef21ab6a4a61dbb0e
-  data.tar.gz: 742f43fcdce4a592a80ebe8e3acbd020f39f569cf323621a527e626ae8c6154f7dedb32739b8b62f38e98997ed414ec30471160332ecfb4a2fe5d5052e871333
+  metadata.gz: 8d1d40bf5d19b37f6a2ee8cce73e36027140ae402d27326c15e39a961217153e8b269722503ca0a8a3b592bee50cb6227fffcd812f62a1ec8a1bf94219270eea
+  data.tar.gz: 627df7fb0bd23b641f0b1a40434a6384def8f32bf318b4f92d243266ee0c3145059adc29ea487dcdc30c914045e5737bca92bff6bd67fd06527f97c2e4690fb8

data/CHANGELOG.md

@@ -1,3 +1,22 @@
+## 0.54.1 - April 26, 2025
+- Retire more RubyVM-specific code (#797)
+- Add additional docs for key classes, modules and methods (#802)
+- Populate location information from RBS files (#768)
+- Consolidate parameter handling into Pin::Callable (#844)
+- Adjust local variable presence to start after assignment, not before (#864)
+- Resolve params from ref tags (#872)
+- Reduce use of ComplexType.parse() to preserve rooted? information (#870)
+- Ensure yield return types are qualified (#886)
+- Understand type of 'def foo; @foo ||= bar; end' reader methods (#888)
+- Improvements to #inspect output on pins and chains (#895)
+- Block method resolution improvements (#885)
+- Understand mass assignment into instance variables (#893)
+- Library sync and cache invalidation (#903)
+- Handle super and yield scenarios from blocks (#891)
+- Allow core and stdlib documentation to be uncached (#899)
+- Surface variable names in LSP, e.g., textDocument/hover (#910)
+- Keep idle progress notifications alive (#911)
+
 ## 0.54.0 - April 14, 2025
 - Add support for simple block argument destructuring (#821)
 - Benchmark the typecheck command (#852)

data/lib/solargraph/api_map/store.rb

@@ -3,6 +3,9 @@
 
 module Solargraph
   class ApiMap
+    # Queryable collection of Pins representing a Workspace, gems and the Ruby
+    # core.
+    #
     class Store
       # @return [Array<Solargraph::Pin::Base>]
       attr_reader :pins
@@ -35,6 +38,7 @@ module Solargraph
       # @param fqns [String]
       # @return [String, nil]
       def get_superclass fqns
+        raise "Do not prefix fully qualified namespaces with '::' - #{fqns.inspect}" if fqns.start_with?('::')
         return superclass_references[fqns].first if superclass_references.key?(fqns)
         return 'Object' if fqns != 'BasicObject' && namespace_exists?(fqns)
         return 'Object' if fqns == 'Boolean'
@@ -100,7 +104,7 @@ module Solargraph
         @namespaces ||= Set.new
       end
 
-      # @return [Array<Solargraph::Pin::Base>]
+      # @return [Enumerable<Solargraph::Pin::Base>]
       def namespace_pins
         pins_by_class(Solargraph::Pin::Namespace)
       end
@@ -146,7 +150,7 @@ module Solargraph
 
       # @generic T
       # @param klass [Class<T>]
-      # @return [Array<T>]
+      # @return [Set<T>]
       def pins_by_class klass
         # @type [Set<Solargraph::Pin::Base>]
         s = Set.new

data/lib/solargraph/api_map.rb

@@ -5,7 +5,7 @@ require 'yard'
 require 'solargraph/yard_tags'
 
 module Solargraph
-  # An aggregate provider for information about workspaces, sources, gems, and
+  # An aggregate provider for information about Workspaces, Sources, gems, and
   # the Ruby core.
   #
   class ApiMap
@@ -250,18 +250,20 @@ module Solargraph
     # @param tag [String, nil] The namespace to
     #   match, complete with generic parameters set to appropriate
     #   values if available
-    # @param context_tag [String] The context in which the tag was
-    #   referenced; start from here to resolve the name
+    # @param context_tag [String] The fully qualified context in which
+    #   the tag was referenced; start from here to resolve the name.
+    #   Should not be prefixed with '::'.
     # @return [String, nil] fully qualified tag
     def qualify tag, context_tag = ''
       return tag if ['self', nil].include?(tag)
-      context_type = ComplexType.try_parse(context_tag)
+
+      context_type = ComplexType.parse(context_tag).force_rooted
       return unless context_type
 
       type = ComplexType.try_parse(tag)
       return unless type
 
-      fqns = qualify_namespace(type.rooted_namespace, context_type.rooted_namespace)
+      fqns = qualify_namespace(type.rooted_namespace, context_type.namespace)
       return unless fqns
 
       fqns + type.substring
@@ -326,6 +328,11 @@ module Solargraph
       store.pins_by_class(Pin::GlobalVariable)
     end
 
+    # @return [Enumerable<Solargraph::Pin::Block>]
+    def get_block_pins
+      store.pins_by_class(Pin::Block)
+    end
+
     # Get an array of methods available in a particular context.
     #
     # @param rooted_tag [String] The fully qualified namespace to search for methods
@@ -591,7 +598,7 @@ module Solargraph
     # @param no_core [Boolean] Skip core classes if true
     # @return [Array<Pin::Base>]
     def inner_get_methods rooted_tag, scope, visibility, deep, skip, no_core = false
-      rooted_type = ComplexType.parse(rooted_tag)
+      rooted_type = ComplexType.parse(rooted_tag).force_rooted
       fqns = rooted_type.namespace
       fqns_generic_params = rooted_type.all_params
       return [] if no_core && fqns =~ /^(Object|BasicObject|Class|Module)$/
@@ -629,7 +636,7 @@ module Solargraph
             # @todo perform the same translation in the other areas
             #  here after adding a spec and handling things correctly
             #  in ApiMap::Store and RbsMap::Conversions
-            resolved_include_type = ComplexType.parse(rooted_include_tag).resolve_generics(namespace_pin, rooted_type)
+            resolved_include_type = ComplexType.parse(rooted_include_tag).force_rooted.resolve_generics(namespace_pin, rooted_type)
             methods = inner_get_methods(resolved_include_type.tag, scope, visibility, deep, skip, true)
             result.concat methods
           end
@@ -690,7 +697,7 @@ module Solargraph
 
     # @param namespace [String]
     # @param context [String]
-    # @return [String]
+    # @return [String, nil]
     def qualify_lower namespace, context
       qualify namespace, context.split('::')[0..-2].join('::')
     end

data/lib/solargraph/complex_type/type_methods.rb

@@ -12,12 +12,20 @@ module Solargraph
     #     @rooted: boolish
     #   methods:
     #     transform()
+    #     all_params()
+    #     rooted?()
+    #     can_root_name?()
     module TypeMethods
       # @!method transform(new_name = nil, &transform_type)
       #   @param new_name [String, nil]
       #   @yieldparam t [UniqueType]
       #   @yieldreturn [UniqueType]
       #   @return [UniqueType, nil]
+      # @!method all_params
+      #   @return [Array<ComplexType>]
+      # @!method rooted?
+      # @!method can_root_name?(name_to_check = nil)
+      #   @param name_to_check [String, nil]
 
       # @return [String]
       attr_reader :name
@@ -45,11 +53,6 @@ module Solargraph
         @nil_type ||= (name.casecmp('nil') == 0)
       end
 
-      # @return [Boolean]
-      def parameters?
-        !substring.empty?
-      end
-
       def tuple?
         @tuple_type ||= (name == 'Tuple') || (name == 'Array' && subtypes.length >= 1 && fixed_parameters?)
       end
@@ -128,13 +131,13 @@ module Solargraph
 
       # @return [String]
       def rooted_namespace
-        return namespace unless rooted?
+        return namespace unless rooted? && can_root_name?(namespace)
         "::#{namespace}"
       end
 
       # @return [String]
       def rooted_name
-        return name unless rooted?
+        return name unless @rooted && can_root_name?
         "::#{name}"
       end
 
@@ -177,10 +180,6 @@ module Solargraph
         tag == other.tag
       end
 
-      def rooted?
-        @rooted
-      end
-
       # Generate a ComplexType that fully qualifies this type's namespaces.
       #
       # @param api_map [ApiMap] The ApiMap that performs qualification

data/lib/solargraph/complex_type/unique_type.rb

@@ -26,6 +26,8 @@ module Solargraph
         if name.start_with?('::')
           name = name[2..-1]
           rooted = true
+        elsif !can_root_name?(name)
+          rooted = true
         else
           rooted = false
         end
@@ -63,7 +65,7 @@ module Solargraph
         if parameters_type.nil?
           raise "You must supply parameters_type if you provide parameters" unless key_types.empty? && subtypes.empty?
         end
-        raise "Please remove leading :: and set rooted instead - #{name}" if name.start_with?('::')
+        raise "Please remove leading :: and set rooted instead - #{name.inspect}" if name.start_with?('::')
         @name = name
         @key_types = key_types
         @subtypes = subtypes
@@ -78,6 +80,24 @@ module Solargraph
         tag
       end
 
+      def eql?(other)
+        self.class == other.class &&
+          @name == other.name &&
+          @key_types == other.key_types &&
+          @subtypes == other.subtypes &&
+          @rooted == other.rooted? &&
+          @all_params == other.all_params &&
+          @parameters_type == other.parameters_type
+      end
+
+      def ==(other)
+        eql?(other)
+      end
+
+      def hash
+        [self.class, @name, @key_types, @sub_types, @rooted, @all_params, @parameters_type].hash
+      end
+
       # @return [Array<UniqueType>]
       def items
         [self]
@@ -108,7 +128,11 @@ module Solargraph
           # tuples don't have a name; they're just [foo, bar, baz].
           if substring == '()'
             # but there are no zero element tuples, so we go with an array
-            'Array[]'
+            if rooted?
+              '::Array[]'
+            else
+              'Array[]'
+            end
           else
             # already generated surrounded by []
             parameters_as_rbs
@@ -238,6 +262,7 @@ module Solargraph
       # @return [self]
       def recreate(new_name: nil, make_rooted: nil, new_key_types: nil, new_subtypes: nil)
         raise "Please remove leading :: and set rooted instead - #{new_name}" if new_name&.start_with?('::')
+
         new_name ||= name
         new_key_types ||= @key_types
         new_subtypes ||= @subtypes
@@ -278,17 +303,26 @@ module Solargraph
           new_key_types = @key_types.flat_map { |ct| ct.items.map { |ut| ut.transform(&transform_type) } }
           new_subtypes = @subtypes.flat_map { |ct| ct.items.map { |ut| ut.transform(&transform_type) } }
         end
-        new_type = recreate(new_name: new_name || name, new_key_types: new_key_types, new_subtypes: new_subtypes)
+        new_type = recreate(new_name: new_name || name, new_key_types: new_key_types, new_subtypes: new_subtypes, make_rooted: @rooted)
         yield new_type
       end
 
-      # Transform references to the 'self' type to the specified concrete namespace
-      # @param dst [String]
-      # @return [UniqueType]
-      def self_to dst
+      # Generate a ComplexType that fully qualifies this type's namespaces.
+      #
+      # @param api_map [ApiMap] The ApiMap that performs qualification
+      # @param context [String] The namespace from which to resolve names
+      # @return [self, ComplexType, UniqueType] The generated ComplexType
+      def qualify api_map, context = ''
         transform do |t|
-          next t if t.name != 'self'
-          t.recreate(new_name: dst, new_key_types: [], new_subtypes: [])
+          next t if t.name == GENERIC_TAG_NAME
+          next t if t.duck_type? || t.void? || t.undefined?
+          recon = (t.rooted? ? '' : context)
+          fqns = api_map.qualify(t.name, recon)
+          if fqns.nil?
+            next UniqueType::BOOLEAN if t.tag == 'Boolean'
+            next UniqueType::UNDEFINED
+          end
+          t.recreate(new_name: fqns, make_rooted: true)
         end
       end
 
@@ -296,6 +330,35 @@ module Solargraph
         @name == 'self' || @key_types.any?(&:selfy?) || @subtypes.any?(&:selfy?)
       end
 
+      # @param dst [ComplexType]
+      # @return [self]
+      def self_to_type dst
+        object_type_dst = dst.reduce_class_type
+        transform do |t|
+          next t if t.name != 'self'
+          object_type_dst
+        end
+      end
+
+      def all_rooted?
+        return true if name == GENERIC_TAG_NAME
+        rooted? && all_params.all?(&:rooted?)
+      end
+
+      def rooted?
+        !can_root_name? || @rooted
+      end
+
+      def can_root_name?(name_to_check = name)
+        self.class.can_root_name?(name_to_check)
+      end
+
+      # @param name [String]
+      def self.can_root_name?(name)
+        # name is not lowercase
+        !name.empty? && name != name.downcase
+      end
+
       UNDEFINED = UniqueType.new('undefined', rooted: false)
       BOOLEAN = UniqueType.new('Boolean', rooted: true)
     end

data/lib/solargraph/complex_type.rb

@@ -18,13 +18,27 @@ 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
+    end
+
     # @param api_map [ApiMap]
     # @param context [String]
     # @return [ComplexType]
     def qualify api_map, context = ''
       red = reduce_object
       types = red.items.map do |t|
-        next t if ['Boolean', 'nil', 'void', 'undefined'].include?(t.name)
+        next t if ['nil', 'void', 'undefined'].include?(t.name)
+        next t if ['::Boolean'].include?(t.rooted_name)
         t.qualify api_map, context
       end
       ComplexType.new(types).reduce_object
@@ -52,6 +66,16 @@ module Solargraph
        (@items.length > 1 ? ')' : ''))
     end
 
+    # @param dst [ComplexType]
+    # @return [ComplexType]
+    def self_to_type dst
+      object_type_dst = dst.reduce_class_type
+      transform do |t|
+        next t if t.name != 'self'
+        object_type_dst
+      end
+    end
+
     # @yieldparam [UniqueType]
     # @return [Array]
     def map &block
@@ -171,16 +195,7 @@ module Solargraph
     # @return [ComplexType]
     def resolve_generics definitions, context_type
       result = @items.map { |i| i.resolve_generics(definitions, context_type) }
-      ComplexType.try_parse(*result.map(&:tag))
-    end
-
-    # @param dst [String]
-    # @return [ComplexType]
-    def self_to dst
-      return self unless selfy?
-      red = reduce_class(dst)
-      result = @items.map { |i| i.self_to red }
-      ComplexType.try_parse(*result.map(&:tag))
+      ComplexType.new(result)
     end
 
     def nullable?
@@ -192,14 +207,43 @@ module Solargraph
       @items.first.all_params || []
     end
 
+    # @return [ComplexType]
+    def reduce_class_type
+      new_items = items.flat_map do |type|
+        next type unless ['Module', 'Class'].include?(type.name)
+
+        type.all_params
+      end
+      ComplexType.new(new_items)
+    end
+
+    # every type and subtype in this union have been resolved to be
+    # fully qualified
+    def all_rooted?
+      all?(&:all_rooted?)
+    end
+
+    # every top-level type has resolved to be fully qualified; see
+    # #all_rooted? to check their subtypes as well
+    def rooted?
+      all?(&:rooted?)
+    end
+
     attr_reader :items
 
+    def rooted?
+      @items.all?(&:rooted?)
+    end
+
     protected
 
     # @return [ComplexType]
     def reduce_object
-      return self if name != 'Object' || subtypes.empty?
-      ComplexType.try_parse(reduce_class(subtypes.join(', ')))
+      new_items = items.flat_map do |ut|
+        next [ut] if ut.name != 'Object' || ut.subtypes.empty?
+        ut.subtypes
+      end
+      ComplexType.new(new_items)
     end
 
     def bottom?
@@ -221,10 +265,15 @@ module Solargraph
       #
       # @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
-      #  @param partial [Boolean] True if the string is part of a another type
-      #  @return [Array<UniqueType>]
+      # # @overload parse(*strings, partial: false)
+      # #  @todo Need ability to use a literal true as a type below
+      # #  @param partial [Boolean] True if the string is part of a another type
+      # #  @return [Array<UniqueType>]
+      # @sg-ignore
+      # @todo To be able to select the right signature above,
+      #   Chain::Call needs to know the decl type (:arg, :optarg,
+      #   :kwarg, etc) of the arguments given, instead of just having
+      #   an array of Chains as the arguments.
       def parse *strings, partial: false
         # @type [Hash{Array<String> => ComplexType}]
         @cache ||= {}

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

@@ -6,7 +6,10 @@ module Solargraph
       # A serial worker Thread to handle message.
       #
       # this make check pending message possible, and maybe cancelled to speedup process
+      #
       class MessageWorker
+        UPDATE_METHODS = ['textDocument/didOpen', 'textDocument/didChange', 'workspace/didChangeWatchedFiles'].freeze
+
         # @param host [Host]
         def initialize(host)
           @host = host
@@ -30,7 +33,7 @@ module Solargraph
           @stopped = true
         end
 
-        # @param message [Hash] The message should be handle. will pass back to Host#receive
+        # @param message [Hash] The message to handle. Will be forwarded to Host#receive
         # @return [void]
         def queue(message)
           @mutex.synchronize do
@@ -52,10 +55,33 @@ module Solargraph
         def tick
           message = @mutex.synchronize do
             @resource.wait(@mutex) if messages.empty?
-            messages.shift
+            next_message
           end
           handler = @host.receive(message)
-          handler && handler.send_response
+          handler&.send_response
+        end
+
+        private
+
+        def next_message
+          # 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]
+          messages.delete_at idx
+          msg
+        end
+
+        # True if the message requires a previous update to have executed in
+        # order to work correctly.
+        #
+        def version_dependent? msg
+          msg['textDocument'] && msg['position']
         end
       end
     end

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

@@ -13,10 +13,10 @@ module Solargraph::LanguageServer::Message::TextDocument
     def code_location
       suggestions = host.definitions_at(params['textDocument']['uri'], @line, @column)
       return nil if suggestions.empty?
-      suggestions.reject { |pin| pin.location.nil? || pin.location.filename.nil? }.map do |pin|
+      suggestions.reject { |pin| pin.best_location.nil? || pin.best_location.filename.nil? }.map do |pin|
         {
-          uri: file_to_uri(pin.location.filename),
-          range: pin.location.range.to_hash
+          uri: file_to_uri(pin.best_location.filename),
+          range: pin.best_location.range.to_hash
         }
       end
     end

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

@@ -6,15 +6,15 @@ class Solargraph::LanguageServer::Message::TextDocument::DocumentSymbol < Solarg
   def process
     pins = host.document_symbols params['textDocument']['uri']
     info = pins.map do |pin|
-      next nil unless pin.location&.filename
+      next nil unless pin.best_location&.filename
 
       result = {
         name: pin.name,
         containerName: pin.namespace,
         kind: pin.symbol_kind,
         location: {
-          uri: file_to_uri(pin.location.filename),
-          range: pin.location.range.to_hash
+          uri: file_to_uri(pin.best_location.filename),
+          range: pin.best_location.range.to_hash
         },
         deprecated: pin.deprecated?
       }

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

@@ -21,7 +21,7 @@ module Solargraph
               parts.push pin.documentation unless pin.documentation.nil? || pin.documentation.empty?
               unless parts.empty?
                 data = parts.join("\n\n")
-                next if contents.last && contents.last.end_with?(data)
+                next if contents.last&.end_with?(data)
                 contents.push data
               end
               last_link = this_link unless this_link.nil?

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

@@ -13,10 +13,10 @@ module Solargraph::LanguageServer::Message::TextDocument
     def code_location
       suggestions = host.type_definitions_at(params['textDocument']['uri'], @line, @column)
       return nil if suggestions.empty?
-      suggestions.reject { |pin| pin.location.nil? || pin.location.filename.nil? }.map do |pin|
+      suggestions.reject { |pin| pin.best_location.nil? || pin.best_location.filename.nil? }.map do |pin|
         {
-          uri: file_to_uri(pin.location.filename),
-          range: pin.location.range.to_hash
+          uri: file_to_uri(pin.best_location.filename),
+          range: pin.best_location.range.to_hash
         }
       end
     end

data/lib/solargraph/language_server/message/workspace/workspace_symbol.rb

@@ -6,14 +6,14 @@ class Solargraph::LanguageServer::Message::Workspace::WorkspaceSymbol < Solargra
   def process
     pins = host.query_symbols(params['query'])
     info = pins.map do |pin|
-      uri = file_to_uri(pin.location.filename)
+      uri = file_to_uri(pin.best_location.filename)
       {
         name: pin.path,
         containerName: pin.namespace,
         kind: pin.symbol_kind,
         location: {
           uri: uri,
-          range: pin.location.range.to_hash
+          range: pin.best_location.range.to_hash
         },
         deprecated: pin.deprecated?
       }

data/lib/solargraph/language_server/progress.rb

@@ -66,10 +66,10 @@ module Solargraph
         return unless host.client_supports_progress? && !finished?
 
         message = build
-
-        create(host) unless created?
+        create(host)
         host.send_notification '$/progress', message
         @status = FINISHED if kind == 'end'
+        keep_alive host
       end
 
       def created?
@@ -113,6 +113,23 @@ module Solargraph
           raise "Invalid progress kind #{kind}"
         end
       end
+
+      # @param host [Host]
+      def keep_alive host
+        mutex.synchronize { @last = Time.now }
+        @keep_alive ||= Thread.new do
+          until finished?
+            sleep 10
+            break if finished?
+            next if mutex.synchronize { Time.now - @last < 10 }
+            send host
+          end
+        end
+      end
+
+      def mutex
+        @mutex ||= Mutex.new
+      end
     end
   end
 end