solargraph 0.58.3 → 0.59.0.dev.1

data/lib/solargraph/pin/method.rb

@@ -22,8 +22,9 @@ module Solargraph
       # @param attribute [Boolean]
       # @param signatures [::Array<Signature>, nil]
       # @param anon_splat [Boolean]
+      # @param context [ComplexType, ComplexType::UniqueType, nil]
       def initialize visibility: :public, explicit: true, block: :undefined, node: nil, attribute: false, signatures: nil, anon_splat: false,
-                     **splat
+                     context: nil, **splat
         super(**splat)
         @visibility = visibility
         @explicit = explicit
@@ -32,26 +33,7 @@ module Solargraph
         @attribute = attribute
         @signatures = signatures
         @anon_splat = anon_splat
-      end
-
-      # @param signature_pins [Array<Pin::Signature>]
-      # @return [Array<Pin::Signature>]
-      def combine_all_signature_pins(*signature_pins)
-        # @type [Hash{Array => Array<Pin::Signature>}]
-        by_arity = {}
-        signature_pins.each do |signature_pin|
-          by_arity[signature_pin.arity] ||= []
-          by_arity[signature_pin.arity] << signature_pin
-        end
-        by_arity.transform_values! do |same_arity_pins|
-          # @param memo [Pin::Signature, nil]
-          # @param signature [Pin::Signature]
-          same_arity_pins.reduce(nil) do |memo, signature|
-            next signature if memo.nil?
-            memo.combine_with(signature)
-          end
-        end
-        by_arity.values.flatten
+        @context = context if context
       end
 
       # @param other [Pin::Method]
@@ -66,20 +48,6 @@ module Solargraph
         end
       end
 
-      # @param other [Pin::Method]
-      # @return [Array<Pin::Signature>]
-      def combine_signatures(other)
-        all_undefined = signatures.all? { |sig| sig.return_type.undefined? }
-        other_all_undefined = other.signatures.all? { |sig| sig.return_type.undefined? }
-        if all_undefined && !other_all_undefined
-          other.signatures
-        elsif other_all_undefined && !all_undefined
-          signatures
-        else
-          combine_all_signature_pins(*signatures, *other.signatures)
-        end
-      end
-
       def combine_with(other, attrs = {})
         priority_choice = choose_priority(other)
         return priority_choice unless priority_choice.nil?
@@ -92,7 +60,6 @@ module Solargraph
         end
         new_attrs = {
           visibility: combine_visibility(other),
-          # @sg-ignore https://github.com/castwide/solargraph/pull/1050
           explicit: explicit? || other.explicit?,
           block: combine_blocks(other),
           node: choose_node(other, :node),
@@ -160,6 +127,8 @@ module Solargraph
         !block.nil?
       end
 
+      # @sg-ignore flow sensitive typing needs to remove literal with
+      #   this unless block
       # @return [Pin::Signature, nil]
       def block
         return @block unless @block == :undefined
@@ -179,9 +148,10 @@ module Solargraph
       end
 
       # @param parameters [::Array<Parameter>]
-      # @param return_type [ComplexType]
+      # @param return_type [ComplexType, nil]
       # @return [Signature]
       def generate_signature(parameters, return_type)
+        # @type [Pin::Signature, nil]
         block = nil
         yieldparam_tags = docstring.tags(:yieldparam)
         yieldreturn_tags = docstring.tags(:yieldreturn)
@@ -202,6 +172,7 @@ module Solargraph
               comments: p.text,
               name: name,
               decl: decl,
+              # @sg-ignore flow sensitive typing needs to handle attrs
               presence: location ? location.range : nil,
               return_type: ComplexType.try_parse(*p.types),
               source: source
@@ -247,6 +218,7 @@ module Solargraph
         else
           "(#{signatures.first.parameters.map(&:full).join(', ')}) " unless signatures.first.parameters.empty?
         end.to_s
+        # @sg-ignore Need to add nil check here
         detail += "=#{probed? ? '~' : (proxied? ? '^' : '>')} #{return_type.to_s}" unless return_type.undefined?
         detail.strip!
         return nil if detail.empty?
@@ -276,6 +248,7 @@ module Solargraph
         return nil if signatures.empty?
 
         rbs = "def #{name}: #{signatures.first.to_rbs}"
+        # @sg-ignore Need to add nil check here
         signatures[1..].each do |sig|
           rbs += "\n"
           rbs += (' ' * (4 + name.length))
@@ -294,6 +267,7 @@ module Solargraph
       end
 
       def typify api_map
+        # @sg-ignore Need to add nil check here
         logger.debug { "Method#typify(self=#{self}, binder=#{binder}, closure=#{closure}, context=#{context.rooted_tags}, return_type=#{return_type.rooted_tags}) - starting" }
         decl = super
         unless decl.undefined?
@@ -303,6 +277,7 @@ module Solargraph
         type = see_reference(api_map) || typify_from_super(api_map)
         logger.debug { "Method#typify(self=#{self}) - type=#{type&.rooted_tags.inspect}" }
         unless type.nil?
+          # @sg-ignore Need to add nil check here
           qualified = type.qualify(api_map, *closure.gates)
           logger.debug { "Method#typify(self=#{self}) => #{qualified.rooted_tags.inspect}" }
           return qualified
@@ -396,7 +371,7 @@ module Solargraph
         attribute? ? infer_from_iv(api_map) : infer_from_return_nodes(api_map)
       end
 
-      # @return [::Array<Pin::Method>]
+      # @return [::Array<Pin::Signature>]
       def overloads
         # Ignore overload tags with nil parameters. If it's not an array, the
         # tag's source is likely malformed.
@@ -414,6 +389,7 @@ module Solargraph
                 comments: tag.docstring.all.to_s,
                 name: name,
                 decl: decl,
+                # @sg-ignore flow sensitive typing needs to handle attrs
                 presence: location ? location.range : nil,
                 return_type: param_type_from_name(tag, src.first),
                 source: :overloads
@@ -468,10 +444,12 @@ module Solargraph
 
       attr_writer :documentation
 
+      # @sg-ignore Need to add nil check here
       def dodgy_visibility_source?
         # as of 2025-03-12, the RBS generator used for
         # e.g. activesupport did not understand 'private' markings
         # inside 'class << self' blocks, but YARD did OK at it
+        # @sg-ignore Need to add nil check here
         source == :rbs && scope == :class && type_location&.filename&.include?('generated') && return_type.undefined? ||
           # YARD's RBS generator seems to miss a lot of should-be protected instance methods
           source == :rbs && scope == :instance && namespace.start_with?('YARD::') ||
@@ -485,6 +463,71 @@ module Solargraph
 
       private
 
+      # @param other [Pin::Method]
+      # @return [Array<Pin::Signature>]
+      def combine_signatures(other)
+        all_undefined = signatures.all? { |sig| !sig.return_type&.defined? }
+        other_all_undefined = other.signatures.all? { |sig| !sig.return_type&.defined? }
+        if all_undefined && !other_all_undefined
+          other.signatures
+        elsif other_all_undefined && !all_undefined
+          signatures
+        else
+          combine_signatures_by_type_arity(*signatures, *other.signatures)
+        end
+      end
+
+      # @param signature_pins [Array<Pin::Signature>]
+      #
+      # @return [Array<Pin::Signature>]
+      def combine_signatures_by_type_arity(*signature_pins)
+        # @type [Hash{Array => Array<Pin::Signature>}]
+        by_type_arity = {}
+        signature_pins.each do |signature_pin|
+          by_type_arity[signature_pin.type_arity] ||= []
+          by_type_arity[signature_pin.type_arity] << signature_pin
+        end
+
+        by_type_arity.transform_values! do |same_type_arity_signatures|
+          combine_same_type_arity_signatures same_type_arity_signatures
+        end
+        by_type_arity.values.flatten
+      end
+
+      # @param same_type_arity_signatures [Array<Pin::Signature>]
+      #
+      # @return [Array<Pin::Signature>]
+      def combine_same_type_arity_signatures(same_type_arity_signatures)
+        # This is an O(n^2) operation, so bail out if n is not small
+        return same_type_arity_signatures if same_type_arity_signatures.length > 10
+
+        # @param old_signatures [Array<Pin::Signature>]
+        # @param new_signature [Pin::Signature]
+        same_type_arity_signatures.reduce([]) do |old_signatures, new_signature|
+          next [new_signature] if old_signatures.empty?
+
+          found_merge = false
+          old_signatures.flat_map do |old_signature|
+            potential_new_signature = old_signature.combine_with(new_signature)
+
+            if potential_new_signature.type_arity == old_signature.type_arity
+              # the number of types in each parameter and return type
+              # match, so we found compatible signatures to merge.  If
+              # we increased the number of types, we'd potentially
+              # have taken away the ability to use parameter types to
+              # choose the correct return type (while Ruby doesn't
+              # dispatch based on type, RBS does distinguish overloads
+              # based on types, not just arity, allowing for type
+              # information describing how methods behave based on
+              # their input types)
+              old_signatures - [old_signature] + [potential_new_signature]
+            else
+              old_signatures + [new_signature]
+            end
+          end
+        end
+      end
+
       # @param name [String]
       # @param asgn [Boolean]
       #
@@ -532,19 +575,20 @@ module Solargraph
       end
 
       # @param api_map [ApiMap]
-      # @return [ComplexType, nil]
+      # @return [ComplexType, ComplexType::UniqueType, nil]
       def see_reference api_map
         # This should actually be an intersection type
-        # @param ref [YARD::Tags::Tag, Solargraph::Yard::Tags::RefTag]
+        # @param ref [YARD::Tags::Tag, YARD::Tags::RefTag]
         docstring.ref_tags.each do |ref|
           # @sg-ignore ref should actually be an intersection type
           next unless ref.tag_name == 'return' && ref.owner
-          # @sg-ignore ref should actually be an intersection type
+          # @sg-ignore should actually be an intersection type
           result = resolve_reference(ref.owner.to_s, api_map)
           return result unless result.nil?
         end
         match = comments.match(/^[ \t]*\(see (.*)\)/m)
         return nil if match.nil?
+        # @sg-ignore Need to add nil check here
         resolve_reference match[1], api_map
       end
 
@@ -559,6 +603,7 @@ module Solargraph
         stack = rest_of_stack api_map
         return nil if stack.empty?
         stack.each do |pin|
+          # @sg-ignore Need to add nil check here
           return pin.return_type unless pin.return_type.undefined?
         end
         nil
@@ -566,7 +611,7 @@ module Solargraph
 
       # @param ref [String]
       # @param api_map [ApiMap]
-      # @return [ComplexType, nil]
+      # @return [ComplexType, ComplexType::UniqueType, nil]
       def resolve_reference ref, api_map
         parts = ref.split(/[.#]/)
         if parts.first.empty? || parts.one?
@@ -574,6 +619,7 @@ module Solargraph
         else
           fqns = api_map.qualify(parts.first, *gates)
           return ComplexType::UNDEFINED if fqns.nil?
+          # @sg-ignore Need to add nil check here
           path = fqns + ref[parts.first.length] + parts.last
         end
         pins = api_map.get_path_pins(path)
@@ -609,9 +655,11 @@ module Solargraph
           rng = Range.from_node(n)
           next unless rng
           clip = api_map.clip_at(
+            # @sg-ignore Need to add nil check here
             location.filename,
             rng.ending
           )
+          # @sg-ignore Need to add nil check here
           chain = Solargraph::Parser.chain(n, location.filename)
           type = chain.infer(api_map, self, clip.locals)
           result.push type unless type.undefined?

data/lib/solargraph/pin/method_alias.rb

@@ -26,6 +26,14 @@ module Solargraph
         :public
       end
 
+      def to_rbs
+        if scope == :class
+          "alias self.#{name} self.#{original}"
+        else
+          "alias #{name} #{original}"
+        end
+      end
+
       def path
         @path ||= namespace + (scope == :instance ? '#' : '.') + name
       end

data/lib/solargraph/pin/namespace.rb

@@ -26,7 +26,6 @@ module Solargraph
         @type = type
         @visibility = visibility
         if name.start_with?('::')
-          # @type [String]
           name = name[2..-1] || ''
           @closure = Solargraph::Pin::ROOT_PIN
         end
@@ -39,6 +38,7 @@ module Solargraph
           closure_name = if [Solargraph::Pin::ROOT_PIN, nil].include?(closure)
             ''
           else
+            # @sg-ignore Need to add nil check here
             closure.full_context.namespace + '::'
           end
           closure_name += parts.join('::')
@@ -48,6 +48,12 @@ module Solargraph
         @name = name
       end
 
+      def reset_generated!
+        @return_type = nil
+        @full_context = nil
+        @path = nil
+      end
+
       def to_rbs
         "#{@type.to_s} #{return_type.all_params.first.to_rbs}#{rbs_generics}".strip
       end

data/lib/solargraph/pin/parameter.rb

@@ -30,12 +30,29 @@ module Solargraph
       end
 
       def combine_with(other, attrs={})
-        new_attrs = {
-          decl: assert_same(other, :decl),
-          presence: choose(other, :presence),
-          asgn_code: choose(other, :asgn_code),
-        }.merge(attrs)
-        super(other, new_attrs)
+        # Parameters can be combined with local variables
+        new_attrs = if other.is_a?(Parameter)
+                      {
+                        decl: assert_same(other, :decl),
+                        asgn_code: choose(other, :asgn_code)
+                      }
+                    else
+                      {
+                        decl: decl,
+                        asgn_code: asgn_code
+                      }
+                    end
+        super(other, new_attrs.merge(attrs))
+      end
+
+      def combine_return_type(other)
+        out = super
+        if out&.undefined?
+          # allow our return_type method to provide a better type
+          # using :param tag
+          out = nil
+        end
+        out
       end
 
       def keyword?
@@ -43,6 +60,7 @@ module Solargraph
       end
 
       def kwrestarg?
+        # @sg-ignore flow sensitive typing needs to handle attrs
         decl == :kwrestarg || (assignment && [:HASH, :hash].include?(assignment.type))
       end
 
@@ -72,6 +90,11 @@ module Solargraph
         end
       end
 
+      # @return [String]
+      def type_arity_decl
+        arity_decl + return_type.items.count.to_s
+      end
+
       def arg?
         decl == :arg
       end
@@ -80,6 +103,14 @@ module Solargraph
         decl == :restarg
       end
 
+      def mandatory_positional?
+        decl == :arg
+      end
+
+      def positional?
+        !keyword?
+      end
+
       def rest?
         decl == :restarg || decl == :kwrestarg
       end
@@ -123,6 +154,11 @@ module Solargraph
         end
       end
 
+      def reset_generated!
+        @return_type = nil if param_tag
+        super
+      end
+
       # @return [String]
       def full
         full_name + case decl
@@ -135,12 +171,14 @@ module Solargraph
                     end
       end
 
+      # @sg-ignore super always sets @return_type to something
       # @return [ComplexType]
       def return_type
         if @return_type.nil?
           @return_type = ComplexType::UNDEFINED
           found = param_tag
           @return_type = ComplexType.try_parse(*found.types) unless found.nil? or found.types.nil?
+          # @sg-ignore flow sensitive typing should be able to handle redefinition
           if @return_type.undefined?
             if decl == :restarg
               @return_type = ComplexType.try_parse('::Array')
@@ -152,22 +190,29 @@ module Solargraph
           end
         end
         super
-        @return_type
       end
 
       # The parameter's zero-based location in the block's signature.
       #
+      # @sg-ignore Need to add nil check here
       # @return [Integer]
       def index
-        # @type [Method, Block]
         method_pin = closure
+        # @sg-ignore Need to add nil check here
         method_pin.parameter_names.index(name)
       end
 
       # @param api_map [ApiMap]
       def typify api_map
-        return return_type.qualify(api_map, *closure.gates) unless return_type.undefined?
-        closure.is_a?(Pin::Block) ? typify_block_param(api_map) : typify_method_param(api_map)
+        new_type = super
+        return new_type if new_type.defined?
+
+        # sniff based on param tags
+        new_type = closure.is_a?(Pin::Block) ? typify_block_param(api_map) : typify_method_param(api_map)
+
+        return adjust_type api_map, new_type.self_to_type(full_context) if new_type.defined?
+
+        adjust_type api_map, super.self_to_type(full_context)
       end
 
       # @param atype [ComplexType]
@@ -176,9 +221,16 @@ module Solargraph
         # make sure we get types from up the method
         # inheritance chain if we don't have them on this pin
         ptype = typify api_map
-        ptype.undefined? || ptype.can_assign?(api_map, atype) || ptype.generic?
+        return true if ptype.undefined?
+
+        return true if atype.conforms_to?(api_map,
+                                          ptype,
+                                          :method_call,
+                                          [:allow_empty_params, :allow_undefined])
+        ptype.generic?
       end
 
+      # @sg-ignore flow sensitive typing needs to handle attrs
       def documentation
         tag = param_tag
         return '' if tag.nil? || tag.text.nil?
@@ -187,12 +239,19 @@ module Solargraph
 
       private
 
+      def generate_complex_type
+        nil
+      end
+
       # @return [YARD::Tags::Tag, nil]
       def param_tag
+        # @sg-ignore Need to add nil check here
         params = closure.docstring.tags(:param)
+        # @sg-ignore Need to add nil check here
         params.each do |p|
           return p if p.name == name
         end
+        # @sg-ignore Need to add nil check here
         params[index] if index && params[index] && (params[index].name.nil? || params[index].name.empty?)
       end
 
@@ -200,7 +259,7 @@ module Solargraph
       # @return [ComplexType]
       def typify_block_param api_map
         block_pin = closure
-        if block_pin.is_a?(Pin::Block) && block_pin.receiver
+        if block_pin.is_a?(Pin::Block) && block_pin.receiver && index
           return block_pin.typify_parameters(api_map)[index]
         end
         ComplexType::UNDEFINED
@@ -209,6 +268,7 @@ module Solargraph
       # @param api_map [ApiMap]
       # @return [ComplexType]
       def typify_method_param api_map
+        # @sg-ignore Need to add nil check here
         meths = api_map.get_method_stack(closure.full_context.tag, closure.name, scope: closure.scope)
         # meths.shift # Ignore the first one
         meths.each do |meth|
@@ -222,6 +282,7 @@ module Solargraph
           if found.nil? and !index.nil?
             found = params[index] if params[index] && (params[index].name.nil? || params[index].name.empty?)
           end
+          # @sg-ignore Need to add nil check here
           return ComplexType.try_parse(*found.types).qualify(api_map, *meth.closure.gates) unless found.nil? || found.types.nil?
         end
         ComplexType::UNDEFINED
@@ -230,6 +291,7 @@ module Solargraph
       # @param heredoc [YARD::Docstring]
       # @param api_map [ApiMap]
       # @param skip [::Array]
+      #
       # @return [::Array<YARD::Tags::Tag>]
       def see_reference heredoc, api_map, skip = []
         # This should actually be an intersection type
@@ -237,7 +299,7 @@ module Solargraph
         heredoc.ref_tags.each do |ref|
           # @sg-ignore ref should actually be an intersection type
           next unless ref.tag_name == 'param' && ref.owner
-          # @sg-ignore ref should actually be an intersection type
+          # @todo ref should actually be an intersection type
           result = resolve_reference(ref.owner.to_s, api_map, skip)
           return result unless result.nil?
         end
@@ -257,6 +319,7 @@ module Solargraph
         else
           fqns = api_map.qualify(parts.first, namespace)
           return nil if fqns.nil?
+          # @sg-ignore Need to add nil check here
           path = fqns + ref[parts.first.length] + parts.last
         end
         pins = api_map.get_path_pins(path)

data/lib/solargraph/pin/proxy_type.rb

@@ -3,7 +3,7 @@
 module Solargraph
   module Pin
     class ProxyType < Base
-      # @param return_type [ComplexType]
+      # @param return_type [ComplexType, ComplexType::UniqueType]
       # @param gates [Array<String>, nil] Namespaces to try while resolving non-rooted types
       # @param binder [ComplexType, ComplexType::UniqueType, nil]
       # @param gates [Array<String>, nil]
@@ -25,6 +25,7 @@ module Solargraph
       def self.anonymous context, closure: nil, binder: nil, **kwargs
         unless closure
           parts = context.namespace.split('::')
+          # @sg-ignore Need to add nil check here
           namespace = parts[0..-2].join('::').to_s
           closure = Solargraph::Pin::Namespace.new(name: namespace, source: :proxy_type)
         end

data/lib/solargraph/pin/reference/override.rb

@@ -7,7 +7,7 @@ module Solargraph
         # @return [::Array<YARD::Tags::Tag>]
         attr_reader :tags
 
-        # @return [::Array<Symbol>]
+        # @return [::Array<::Symbol>]
         attr_reader :delete
 
         def closure

data/lib/solargraph/pin/reference/superclass.rb

@@ -6,7 +6,9 @@ module Solargraph
       # A Superclass reference pin.
       #
       class Superclass < Reference
+        # @sg-ignore Need to add nil check here
         def reference_gates
+          # @sg-ignore Need to add nil check here
           @reference_gates ||= closure.gates - [closure.path]
         end
       end

data/lib/solargraph/pin/reference.rb

@@ -30,8 +30,10 @@ module Solargraph
         )
       end
 
+      # @sg-ignore Need to add nil check here
       # @return [Array<String>]
       def reference_gates
+        # @sg-ignore Need to add nil check here
         closure.gates
       end
     end

data/lib/solargraph/pin/search.rb

@@ -51,6 +51,7 @@ module Solargraph
 
       # @param str1 [String]
       # @param str2 [String]
+      #
       # @return [Float]
       def fuzzy_string_match str1, str2
         return 1.0 + (str2.length.to_f / str1.length.to_f) if str1.downcase.include?(str2.downcase)

data/lib/solargraph/pin/signature.rb

@@ -10,6 +10,7 @@ module Solargraph
       end
 
       def generics
+        # @type [Array<::String, nil>]
         @generics ||= [].freeze
       end
 
@@ -19,6 +20,7 @@ module Solargraph
 
       attr_writer :closure
 
+      # @ sg-ignore need boolish support for ? methods
       def dodgy_return_type_source?
         super || closure&.dodgy_return_type_source?
       end
@@ -32,8 +34,11 @@ module Solargraph
       end
 
       def typify api_map
+        # @sg-ignore Need to add nil check here
         if return_type.defined?
+          # @sg-ignore Need to add nil check here
           qualified = return_type.qualify(api_map, closure.namespace)
+          # @sg-ignore Need to add nil check here
           logger.debug { "Signature#typify(self=#{self}) => #{qualified.rooted_tags.inspect}" }
           return qualified
         end
@@ -46,8 +51,11 @@ module Solargraph
         method_stack.each do |pin|
           sig = pin.signatures.find { |s| s.arity == self.arity }
           next unless sig
+          # @sg-ignore Need to add nil check here
           unless sig.return_type.undefined?
+            # @sg-ignore Need to add nil check here
             qualified = sig.return_type.qualify(api_map, closure.namespace)
+            # @sg-ignore Need to add nil check here
             logger.debug { "Signature#typify(self=#{self}) => #{qualified.rooted_tags.inspect}" }
             return qualified
           end

data/lib/solargraph/pin/symbol.rb

@@ -3,7 +3,7 @@
 module Solargraph
   module Pin
     class Symbol < Base
-      # @param location [Solargraph::Location]
+      # @param location [Solargraph::Location, nil]
       # @param name [String]
       def initialize(location, name, **kwargs)
         # @sg-ignore "Unrecognized keyword argument kwargs to Solargraph::Pin::Base#initialize"

data/lib/solargraph/pin/until.rb

@@ -2,7 +2,7 @@
 
 module Solargraph
   module Pin
-    class Until < Base
+    class Until < CompoundStatement
       include Breakable
 
       # @param receiver [Parser::AST::Node, nil]

data/lib/solargraph/pin/while.rb

@@ -2,7 +2,7 @@
 
 module Solargraph
   module Pin
-    class While < Base
+    class While < CompoundStatement
       include Breakable
 
       # @param receiver [Parser::AST::Node, nil]

data/lib/solargraph/pin.rb

@@ -38,6 +38,8 @@ module Solargraph
     autoload :Until,            'solargraph/pin/until'
     autoload :While,            'solargraph/pin/while'
     autoload :Callable,         'solargraph/pin/callable'
+    autoload :CompoundStatement,
+             'solargraph/pin/compound_statement'
 
     ROOT_PIN = Pin::Namespace.new(type: :class, name: '', closure: nil, source: :pin_rb)
   end