solargraph 0.54.4 → 0.55.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 469236908941a1221785c7add8041544e118731b99e8a81b766856b96acbb307
-  data.tar.gz: 6f2cf614a67abd04e53bb3a30a5ce2bc51b6b9cac16c474818e959c1e4c582ab
+  metadata.gz: c8e98755e559a9524b7d057c860e1ebb6d8a46eeb73dd567744f7562a4d49a64
+  data.tar.gz: 33943305fcf0c4c534fd4abf5eb24a937f6390021e681017296aac7bb9546592
 SHA512:
-  metadata.gz: 22777792098e88c264a08e8a9785df73e00b1ed20fbfb4efe0988f9cb8aa5deec93ae520961672f2848ac7b2bf02fefccbb83a14e0c9092c2e18bd861d938f0b
-  data.tar.gz: f154c4badced68ac0ab43bfe43c380009787c424f909801da183fdaf63e9a818daf62eb7ddb904172b9f91957d634758732460aab317235bf163c9d26921f452
+  metadata.gz: 37c0b331d67d299a865e4201c030dec6c1fd4ca14955012d702a44849bece0497c70449a3594ce8cdfe56669b93fbc80d1b291331a540453409a990344464ac1
+  data.tar.gz: c91397eeb5d2f10c551e97a741acb9a1e8fbae371b810bf375cc6024fc5985d6e2e581fb1d39c62ba9dd7f71b2cc6fa0ca801fcb74c89b5b8717beeaf8af10f0

data/CHANGELOG.md

@@ -1,3 +1,21 @@
+## 0.55.0 - June 3, 2025
+- Flow-sensitive typing - automatically downcast from is_a? calls (#856)
+- Tuple enabler: infer literal types and use them for signature selection (#836)
+- Signature selection improvements (#907)
+- Add support for Ruby Structs (#939)
+- [regression] Fix interface change breaking solargraph-rails (#940)
+- [regression] Add back bundler/require support for solargraph-rails (#941)
+- Add specs for initialize capabilities (#955)
+- Create MethodAlias pins from YARD (#945)
+- MessageWorker prioritizes synchronization (#956)
+- initialize/new method pin cleanups (#949)
+- Clip rebinds blocks when cursor is not part of receiver (#958)
+
+## 0.54.5 - May 17, 2025
+- Repair unknown encoding errors (#936, #935)
+- Index arbitrary pinsets (#937)
+- Separate YARD cache from doc map cache (#938)
+
 ## 0.54.4 - May 14, 2025
 - Delete files from Library hash (#932)
 - Clip#define returns variable pins (#934, #933)

data/lib/solargraph/api_map/index.rb

@@ -4,7 +4,7 @@ module Solargraph
   class ApiMap
     class Index
       # @param pins [Array<Pin::Base>]
-      def initialize pins
+      def initialize pins = []
         catalog pins
       end
 

data/lib/solargraph/api_map/store.rb

@@ -1,18 +1,14 @@
 # frozen_string_literal: true
 
-
 module Solargraph
   class ApiMap
     # Queryable collection of Pins representing a Workspace, gems and the Ruby
     # core.
     #
     class Store
-      # @param static [Enumerable<Pin::Base>]
-      # @param dynamic [Enumerable<Pin::Base>]
-      def initialize static = [], dynamic = []
-        @static_index = Index.new(static)
-        @dynamic = dynamic
-        @index = @static_index.merge(dynamic)
+      # @param pinsets [Array<Enumerable<Pin::Base>>]
+      def initialize *pinsets
+        catalog pinsets
       end
 
       # @return [Array<Solargraph::Pin::Base>]
@@ -20,19 +16,27 @@ module Solargraph
         index.pins
       end
 
-      # @param static [Enumerable<Pin::Base>]
-      # @param dynamic [Enumerable<Pin::Base>]
-      def update! static = [], dynamic = []
+      # @param pinsets [Array<Enumerable<Pin::Base>>]
+      # @return [Boolean] True if the index was updated
+      def update *pinsets
+        return catalog(pinsets) if pinsets.length != @pinsets.length
+
+        changed = pinsets.find_index.with_index { |pinset, idx| @pinsets[idx] != pinset }
+        return false unless changed
+
         # @todo Fix this map
         @fqns_pins_map = nil
-        if @static_index.pins == static
-          return self if @dynamic == dynamic
-        else
-          @static_index = Index.new(static)
+        return catalog(pinsets) if changed == 0
+
+        pinsets[changed..].each_with_index do |pins, idx|
+          @pinsets[changed + idx] = pins
+          @indexes[changed + idx] = if pins.empty?
+            @indexes[changed + idx - 1]
+          else
+            @indexes[changed + idx - 1].merge(pins)
+          end
         end
-        @dynamic = dynamic
-        @index = @static_index.merge(dynamic)
-        self
+        true
       end
 
       def to_s
@@ -69,6 +73,8 @@ module Solargraph
         return superclass_references[fqns].first if superclass_references.key?(fqns)
         return 'Object' if fqns != 'BasicObject' && namespace_exists?(fqns)
         return 'Object' if fqns == 'Boolean'
+        simplified_literal_name = ComplexType.parse("#{fqns}").simplify_literals.name
+        return simplified_literal_name if simplified_literal_name != fqns
         nil
       end
 
@@ -108,7 +114,7 @@ module Solargraph
       # @param fqns [String]
       # @return [Enumerable<Solargraph::Pin::Base>]
       def get_class_variables(fqns)
-        namespace_children(fqns).select{|pin| pin.is_a?(Pin::ClassVariable)}
+        namespace_children(fqns).select { |pin| pin.is_a?(Pin::ClassVariable)}
       end
 
       # @return [Enumerable<Solargraph::Pin::Base>]
@@ -190,7 +196,22 @@ module Solargraph
 
       private
 
-      attr_reader :index
+      def index
+        @indexes.last
+      end
+
+      def catalog pinsets
+        @pinsets = pinsets
+        @indexes = []
+        pinsets.each do |pins|
+          if @indexes.last && pins.empty?
+            @indexes.push @indexes.last
+          else
+            @indexes.push(@indexes.last&.merge(pins) || Solargraph::ApiMap::Index.new(pins))
+          end
+        end
+        true
+      end
 
       # @return [Hash{::Array(String, String) => ::Array<Pin::Namespace>}]
       def fqns_pins_map

data/lib/solargraph/api_map.rb

@@ -66,7 +66,7 @@ module Solargraph
       @source_map_hash = {}
       implicit.clear
       cache.clear
-      store.update! @@core_map.pins, pins
+      store.update @@core_map.pins, pins
       self
     end
 
@@ -85,11 +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))
-      # @todo Work around #to_h problem in current Ruby head (3.5)
-      @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
@@ -98,11 +96,8 @@ 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.update! @@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
@@ -111,7 +106,7 @@ module Solargraph
     #   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>]
@@ -269,15 +264,19 @@ module Solargraph
     #   Should not be prefixed with '::'.
     # @return [String, nil] fully qualified tag
     def qualify tag, context_tag = ''
-      return tag if ['self', nil].include?(tag)
+      return tag if ['Boolean', 'self', nil].include?(tag)
 
-      context_type = ComplexType.parse(context_tag).force_rooted
+      context_type = ComplexType.try_parse(context_tag).force_rooted
       return unless context_type
 
       type = ComplexType.try_parse(tag)
       return unless type
+      return tag if type.literal?
+
+      context_type = ComplexType.try_parse(context_tag)
+      return unless context_type
 
-      fqns = qualify_namespace(type.rooted_namespace, context_type.namespace)
+      fqns = qualify_namespace(type.rooted_namespace, context_type.rooted_namespace)
       return unless fqns
 
       fqns + type.substring
@@ -324,6 +323,11 @@ module Solargraph
       result
     end
 
+    # @see Solargraph::Parser::FlowSensitiveTyping#visible_pins
+    def visible_pins(*args, **kwargs, &blk)
+      Solargraph::Parser::FlowSensitiveTyping.visible_pins(*args, **kwargs, &blk)
+    end
+
     # Get an array of class variable pins for a namespace.
     #
     # @param namespace [String] A fully qualified namespace
@@ -381,7 +385,7 @@ module Solargraph
             init_pin = get_method_stack(rooted_tag, 'initialize').first
             next pin unless init_pin
 
-            type = ComplexType.try_parse(ComplexType.try_parse(rooted_tag).namespace)
+            type = ComplexType::SELF
             Pin::Method.new(
               name: 'new',
               scope: :class,
@@ -390,9 +394,10 @@ module Solargraph
               signatures: init_pin.signatures.map { |sig| sig.proxy(type) },
               return_type: type,
               comments: init_pin.comments,
-              closure: init_pin.closure
-            # @todo Hack to force TypeChecker#internal_or_core?
-            ).tap { |pin| pin.source = :rbs }
+              closure: init_pin.closure,
+              source: init_pin.source,
+              type_location: init_pin.type_location,
+            )
           end
         end
         result.concat inner_get_methods('Kernel', :instance, [:public], deep, skip) if visibility.include?(:private)
@@ -819,7 +824,7 @@ module Solargraph
       return pin unless pin.is_a?(Pin::MethodAlias)
       return nil if @method_alias_stack.include?(pin.path)
       @method_alias_stack.push pin.path
-      origin = get_method_stack(pin.full_context.tag, pin.original, scope: pin.scope).first
+      origin = get_method_stack(pin.full_context.tag, pin.original, scope: pin.scope, preserve_generics: true).first
       @method_alias_stack.pop
       return nil if origin.nil?
       args = {

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/unique_type.rb

@@ -27,7 +27,7 @@ module Solargraph
       # @return [UniqueType]
       def self.parse name, substring = '', make_rooted: nil
         if name.start_with?(':::')
-          raise "Illegal prefix: #{name}"
+          raise ComplexTypeError, "Illegal prefix: #{name}"
         end
         if name.start_with?('::')
           name = name[2..-1]
@@ -48,7 +48,7 @@ module Solargraph
           subs = ComplexType.parse(substring[1..-2], partial: true)
           parameters_type = PARAMETERS_TYPE_BY_STARTING_TAG.fetch(substring[0])
           if parameters_type == :hash
-            raise ComplexTypeError, "Bad hash type" unless !subs.is_a?(ComplexType) and subs.length == 2 and !subs[0].is_a?(UniqueType) and !subs[1].is_a?(UniqueType)
+            raise ComplexTypeError, "Bad hash type: name=#{name}, substring=#{substring}" unless !subs.is_a?(ComplexType) and subs.length == 2 and !subs[0].is_a?(UniqueType) and !subs[1].is_a?(UniqueType)
             # @todo should be able to resolve map; both types have it
             #   with same return type
             # @sg-ignore
@@ -73,19 +73,63 @@ module Solargraph
         end
         raise "Please remove leading :: and set rooted instead - #{name.inspect}" if name.start_with?('::')
         @name = name
-        @key_types = key_types
-        @subtypes = subtypes
+        @parameters_type = parameters_type
+        if implicit_union?
+          @key_types = key_types.uniq
+          @subtypes = subtypes.uniq
+        else
+          @key_types = key_types
+          @subtypes = subtypes
+        end
         @rooted = rooted
         @all_params = []
-        @all_params.concat key_types
-        @all_params.concat subtypes
-        @parameters_type = parameters_type
+        @all_params.concat @key_types
+        @all_params.concat @subtypes
+      end
+
+      def implicit_union?
+        # @todo use api_map to establish number of generics in type;
+        #   if only one is allowed but multiple are passed in, treat
+        #   those as implicit unions
+        ['Hash', 'Array', 'Set', '_ToAry', 'Enumerable', '_Each'].include?(name) && parameters_type != :fixed
       end
 
       def to_s
         tag
       end
 
+      def simplify_literals
+        transform do |t|
+          next t unless t.literal?
+          t.recreate(new_name: t.non_literal_name)
+        end
+      end
+
+      def literal?
+        non_literal_name != name
+      end
+
+      def non_literal_name
+        @non_literal_name ||= determine_non_literal_name
+      end
+
+      def determine_non_literal_name
+        # https://github.com/ruby/rbs/blob/master/docs/syntax.md
+        #
+        # _literal_ ::= _string-literal_
+        #    | _symbol-literal_
+        #    | _integer-literal_
+        #    | `true`
+        #    | `false`
+        return name if name.empty?
+        return 'NilClass' if name == 'nil'
+        return 'Boolean' if ['true', 'false'].include?(name)
+        return 'Symbol' if name[0] == ':'
+        return 'String' if ['"', "'"].include?(name[0])
+        return 'Integer' if name.match?(/^-?\d+$/)
+        name
+      end
+
       def eql?(other)
         self.class == other.class &&
           @name == other.name &&
@@ -113,6 +157,8 @@ module Solargraph
       def rbs_name
         if name == 'undefined'
           'untyped'
+        elsif literal?
+          name
         else
           rooted_name
         end
@@ -183,6 +229,23 @@ module Solargraph
         name == GENERIC_TAG_NAME || all_params.any?(&:generic?)
       end
 
+      # @param api_map [ApiMap] The ApiMap that performs qualification
+      # @param atype [ComplexType] type which may be assigned to this type
+      def can_assign?(api_map, atype)
+        logger.debug { "UniqueType#can_assign?(self=#{rooted_tags.inspect}, atype=#{atype.rooted_tags.inspect})" }
+        downcasted_atype = atype.downcast_to_literal_if_possible
+        out = downcasted_atype.all? do |autype|
+          autype.name == name || api_map.super_and_sub?(name, autype.name)
+        end
+        logger.debug { "UniqueType#can_assign?(self=#{rooted_tags.inspect}, atype=#{atype.rooted_tags.inspect}) => #{out}" }
+        out
+      end
+
+      # @return [UniqueType]
+      def downcast_to_literal_if_possible
+        SINGLE_SUBTYPE.fetch(rooted_tag, self)
+      end
+
       # @param generics_to_resolve [Enumerable<String>]
       # @param context_type [UniqueType, nil]
       # @param resolved_generic_values [Hash{String => ComplexType}] Added to as types are encountered or resolved
@@ -253,6 +316,12 @@ module Solargraph
               else
                 next ComplexType::UNDEFINED
               end
+            elsif context_type.all?(&:implicit_union?)
+              if idx == 0 && !context_type.all_params.empty?
+                ComplexType.new(context_type.all_params)
+              else
+                ComplexType::UNDEFINED
+              end
             else
               context_type.all_params[idx] || ComplexType::UNDEFINED
             end
@@ -381,6 +450,18 @@ module Solargraph
 
       UNDEFINED = UniqueType.new('undefined', rooted: false)
       BOOLEAN = UniqueType.new('Boolean', rooted: true)
+      TRUE = UniqueType.new('true', rooted: true)
+      FALSE = UniqueType.new('false', rooted: true)
+      NIL = UniqueType.new('nil', rooted: true)
+      # @type [Hash{String => UniqueType}]
+      SINGLE_SUBTYPE = {
+        '::TrueClass' => UniqueType::TRUE,
+        '::FalseClass' => UniqueType::FALSE,
+        '::NilClass' => UniqueType::NIL
+      }.freeze
+
+
+      include Logging
     end
   end
 end

data/lib/solargraph/complex_type.rb

@@ -16,7 +16,13 @@ module Solargraph
     def initialize types = [UniqueType::UNDEFINED]
       # @todo @items here should not need an annotation
       # @type [Array<UniqueType>]
-      @items = types.flat_map(&:items).uniq(&:to_s)
+      items = types.flat_map(&:items).uniq(&:to_s)
+      if items.any? { |i| i.name == 'false' } && items.any? { |i| i.name == 'true' }
+        items.delete_if { |i| i.name == 'false' || i.name == 'true' }
+        items.unshift(ComplexType::BOOLEAN)
+      end
+      items = [UniqueType::UNDEFINED] if items.any?(&:undefined?)
+      @items = items
     end
 
     # @sg-ignore Fix "Not enough arguments to Module#protected"
@@ -70,7 +76,7 @@ module Solargraph
     end
 
     # @yieldparam [UniqueType]
-    # @return [Array]
+    # @return [Array<UniqueType>]
     def map &block
       @items.map &block
     end
@@ -93,6 +99,12 @@ module Solargraph
       end
     end
 
+    # @param atype [ComplexType] type which may be assigned to this type
+    # @param api_map [ApiMap] The ApiMap that performs qualification
+    def can_assign?(api_map, atype)
+      any? { |ut| ut.can_assign?(api_map, atype) }
+    end
+
     # @return [Integer]
     def length
       @items.length
@@ -103,10 +115,6 @@ module Solargraph
       @items
     end
 
-    def tags
-      @items.map(&:tag).join(', ')
-    end
-
     # @param index [Integer]
     # @return [UniqueType]
     def [](index)
@@ -147,6 +155,23 @@ module Solargraph
       map(&:tag).join(', ')
     end
 
+    def tags
+      map(&:tag).join(', ')
+    end
+
+    def simple_tags
+      simplify_literals.tags
+    end
+
+    def literal?
+      @items.any?(&:literal?)
+    end
+
+    # @return [ComplexType]
+    def downcast_to_literal_if_possible
+      ComplexType.new(items.map(&:downcast_to_literal_if_possible))
+    end
+
     def desc
       rooted_tags
     end
@@ -175,6 +200,10 @@ module Solargraph
       any?(&:generic?)
     end
 
+    def simplify_literals
+      ComplexType.new(map(&:simplify_literals))
+    end
+
     # @param new_name [String, nil]
     # @yieldparam t [UniqueType]
     # @yieldreturn [UniqueType]

data/lib/solargraph/convention/struct_definition/struct_assignment_node.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Convention
+    module StructDefinition
+      # A node wrapper for a Struct definition via const assignment.
+      # @example
+      #   MyStruct = Struct.new(:bar, :baz) do
+      #     def foo
+      #     end
+      #   end
+      class StructAssignmentNode < StructDefintionNode
+        class << self
+          # @example
+          # s(:casgn, nil, :Foo,
+          #   s(:block,
+          #     s(:send,
+          #       s(:const, nil, :Struct), :new,
+          #       s(:sym, :bar),
+          #       s(:sym, :baz)),
+          #     s(:args),
+          #     s(:def, :foo,
+          #       s(:args),
+          #       s(:send, nil, :bar))))
+          def valid?(node)
+            return false unless node&.type == :casgn
+            return false if node.children[2].nil?
+            struct_node = node.children[2].children[0]
+
+            struct_definition_node?(struct_node)
+          end
+        end
+
+        def class_name
+          if node.children[0]
+            Parser::NodeMethods.unpack_name(node.children[0]) + "::#{node.children[1]}"
+          else
+            node.children[1].to_s
+          end
+        end
+
+        private
+
+        # @return [Parser::AST::Node]
+        def struct_node
+          node.children[2].children[0]
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/convention/struct_definition/struct_definition_node.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Convention
+    module StructDefinition
+      # A node wrapper for a Struct definition via inheritance.
+      # @example
+      #   class MyStruct < Struct.new(:bar, :baz)
+      #     def foo
+      #     end
+      #   end
+      class StructDefintionNode
+        class << self
+          # @example
+          #   s(:class,
+          #     s(:const, nil, :Foo),
+          #     s(:send,
+          #       s(:const, nil, :Struct), :new,
+          #       s(:sym, :bar),
+          #       s(:sym, :baz)),
+          #       s(:hash,
+          #         s(:pair,
+          #           s(:sym, :keyword_init),
+          #           s(:true)))),
+          #     s(:def, :foo,
+          #       s(:args),
+          #       s(:send, nil, :bar)))
+          def valid?(node)
+            return false unless node&.type == :class
+
+            struct_definition_node?(node.children[1])
+          end
+
+          private
+
+          # @param struct_node [Parser::AST::Node]
+          # @return [Boolean]
+          def struct_definition_node?(struct_node)
+            return false unless struct_node.is_a?(::Parser::AST::Node)
+            return false unless struct_node&.type == :send
+            return false unless struct_node.children[0]&.type == :const
+            return false unless struct_node.children[0].children[1] == :Struct
+            return false unless struct_node.children[1] == :new
+
+            true
+          end
+        end
+
+        # @return [Parser::AST::Node]
+        def initialize(node)
+          @node = node
+        end
+
+        # @return [String]
+        def class_name
+          Parser::NodeMethods.unpack_name(node)
+        end
+
+        # @return [Array<Array(Parser::AST::Node, String)>]
+        def attributes
+          struct_attribute_nodes.map do |struct_def_param|
+            next unless struct_def_param.type == :sym
+            [struct_def_param, struct_def_param.children[0].to_s]
+          end.compact
+        end
+
+        def keyword_init?
+          keyword_init_param = struct_attribute_nodes.find do |struct_def_param|
+            struct_def_param.type == :hash && struct_def_param.children[0].type == :pair &&
+              struct_def_param.children[0].children[0].children[0] == :keyword_init
+          end
+
+          return false if keyword_init_param.nil?
+
+          keyword_init_param.children[0].children[1].type == :true
+        end
+
+        # @return [Parser::AST::Node]
+        def body_node
+          node.children[2]
+        end
+
+        private
+
+        # @return [Parser::AST::Node]
+        attr_reader :node
+
+        # @return [Parser::AST::Node]
+        def struct_node
+          node.children[1]
+        end
+
+        # @return [Array<Parser::AST::Node>]
+        def struct_attribute_nodes
+          struct_node.children[2..-1]
+        end
+      end
+    end
+  end
+end