solargraph 0.54.1 → 0.56.0

data/lib/solargraph/pin/base.rb

@@ -8,6 +8,7 @@ module Solargraph
       include Common
       include Conversions
       include Documenting
+      include Logging
 
       # @return [YARD::CodeObjects::Base]
       attr_reader :code_object
@@ -27,17 +28,284 @@ module Solargraph
       # @return [::Symbol]
       attr_accessor :source
 
+      def presence_certain?
+        true
+      end
+
       # @param location [Solargraph::Location, nil]
       # @param type_location [Solargraph::Location, nil]
       # @param closure [Solargraph::Pin::Closure, nil]
       # @param name [String]
       # @param comments [String]
-      def initialize location: nil, type_location: nil, closure: nil, name: '', comments: ''
+      # @param source [Symbol, nil]
+      # @param docstring [YARD::Docstring, nil]
+      # @param directives [::Array<YARD::Tags::Directive>, nil]
+      def initialize location: nil, type_location: nil, closure: nil, source: nil, name: '', comments: '', docstring: nil, directives: nil
         @location = location
         @type_location = type_location
         @closure = closure
         @name = name
         @comments = comments
+        @source = source
+        @identity = nil
+        @docstring = docstring
+        @directives = directives
+        assert_source_provided
+      end
+
+      # @param other [self]
+      # @param attrs [Hash{Symbol => Object}]
+      #
+      # @return [self]
+      def combine_with(other, attrs={})
+        raise "tried to combine #{other.class} with #{self.class}" unless other.class == self.class
+        type_location = choose(other, :type_location)
+        location = choose(other, :location)
+        combined_name = combine_name(other)
+        new_attrs = {
+          location: location,
+          type_location: type_location,
+          name: combined_name,
+          closure: choose_pin_attr_with_same_name(other, :closure),
+          comments: choose_longer(other, :comments),
+          source: :combined,
+          docstring: choose(other, :docstring),
+          directives: combine_directives(other),
+        }.merge(attrs)
+        assert_same_macros(other)
+        logger.debug { "Base#combine_with(path=#{path}) - other.comments=#{other.comments.inspect}, self.comments = #{self.comments}" }
+        out = self.class.new(**new_attrs)
+        out.reset_generated!
+        out
+      end
+
+      # @param other [self]
+      # @param attr [::Symbol]
+      # @sg-ignore
+      # @return [undefined]
+      def choose_longer(other, attr)
+        # @type [undefined]
+        val1 = send(attr)
+        # @type [undefined]
+        val2 = other.send(attr)
+        return val1 if val1 == val2
+        return val2 if val1.nil?
+        # @sg-ignore
+        val1.length > val2.length ? val1 : val2
+      end
+
+      # @param other [self]
+      # @return [::Array<YARD::Tags::Directive>, nil]
+      def combine_directives(other)
+        return self.directives if other.directives.empty?
+        return other.directives if directives.empty?
+        [directives + other.directives].uniq
+      end
+
+      # @param other [self]
+      # @return [String]
+      def combine_name(other)
+        if needs_consistent_name? || other.needs_consistent_name?
+          assert_same(other, :name)
+        else
+          choose(other, :name)
+        end
+      end
+
+      # @return [void]
+      def reset_generated!
+        # @return_type doesn't go here as subclasses tend to assign it
+        # themselves in constructors, and they will deal with setting
+        # it in any methods that call this
+        #
+        # @docstring also doesn't go here, as there is code which
+        # directly manipulates docstring without editing comments
+        # (e.g., Api::Map::Store#index processes overrides that way
+        #
+        # Same with @directives, @macros, @maybe_directives, which
+        # regenerate docstring
+        @deprecated = nil
+        reset_conversions
+      end
+
+      def needs_consistent_name?
+        true
+      end
+
+      # @sg-ignore def should infer as symbol - "Not enough arguments to Module#protected"
+      protected def equality_fields
+        [name, location, type_location, closure, source]
+      end
+
+      # @param other [self]
+      # @return [ComplexType]
+      def combine_return_type(other)
+        if return_type.undefined?
+          other.return_type
+        elsif other.return_type.undefined?
+          return_type
+        elsif dodgy_return_type_source? && !other.dodgy_return_type_source?
+          other.return_type
+        elsif other.dodgy_return_type_source? && !dodgy_return_type_source?
+          return_type
+        else
+          all_items = return_type.items + other.return_type.items
+          if all_items.any? { |item| item.selfy? } && all_items.any? { |item| item.rooted_tag == context.rooted_tag }
+            # assume this was a declaration that should have said 'self'
+            all_items.delete_if { |item| item.rooted_tag == context.rooted_tag }
+          end
+          ComplexType.new(all_items)
+        end
+      end
+
+      def dodgy_return_type_source?
+        # uses a lot of 'Object' instead of 'self'
+        location&.filename&.include?('core_ext/object/')
+      end
+
+      # when choices are arbitrary, make sure the choice is consistent
+      #
+      # @param other [Pin::Base]
+      # @param attr [::Symbol]
+      #
+      # @return [Object, nil]
+      def choose(other, attr)
+        results = [self, other].map(&attr).compact
+        # true and false are different classes and can't be sorted
+        return true if results.any? { |r| r == true || r == false }
+        results.min
+      rescue
+        STDERR.puts("Problem handling #{attr} for \n#{self.inspect}\n and \n#{other.inspect}\n\n#{self.send(attr).inspect} vs #{other.send(attr).inspect}")
+        raise
+      end
+
+      # @param other [self]
+      # @param attr [Symbol]
+      # @sg-ignore
+      # @return [undefined]
+      def choose_node(other, attr)
+        if other.object_id < attr.object_id
+          other.send(attr)
+        else
+          send(attr)
+        end
+      end
+
+      # @param other [self]
+      # @param attr [::Symbol]
+      # @sg-ignore
+      # @return [undefined]
+      def prefer_rbs_location(other, attr)
+        if rbs_location? && !other.rbs_location?
+          self.send(attr)
+        elsif !rbs_location? && other.rbs_location?
+          other.send(attr)
+        else
+          choose(other, attr)
+        end
+      end
+
+      def rbs_location?
+        type_location&.rbs?
+      end
+
+      # @param other [self]
+      # @return [void]
+      def assert_same_macros(other)
+        return unless self.source == :yardoc && other.source == :yardoc
+        assert_same_count(other, :macros)
+        assert_same_array_content(other, :macros) { |macro| macro.tag.name }
+      end
+
+      # @param other [self]
+      # @param attr [::Symbol]
+      # @return [void]
+      # @todo strong typechecking should complain when there are no block-related tags
+      def assert_same_array_content(other, attr, &block)
+        arr1 = send(attr)
+        raise "Expected #{attr} on #{self} to be an Enumerable, got #{arr1.class}" unless arr1.is_a?(::Enumerable)
+        # @type arr1 [::Enumerable]
+        arr2 = other.send(attr)
+        raise "Expected #{attr} on #{other} to be an Enumerable, got #{arr2.class}" unless arr2.is_a?(::Enumerable)
+        # @type arr2 [::Enumerable]
+
+        # @sg-ignore
+        # @type [undefined]
+        values1 = arr1.map(&block)
+        # @type [undefined]
+        values2 = arr2.map(&block)
+        # @sg-ignore
+        return arr1 if values1 == values2
+        Solargraph.assert_or_log("combine_with_#{attr}".to_sym,
+                                 "Inconsistent #{attr.inspect} values between \nself =#{inspect} and \nother=#{other.inspect}:\n\n self values = #{values1}\nother values =#{attr} = #{values2}")
+        arr1
+      end
+
+      # @param other [self]
+      # @param attr [::Symbol]
+      #
+      # @return [::Enumerable]
+      def assert_same_count(other, attr)
+        # @type [::Enumerable]
+        arr1 = self.send(attr)
+        raise "Expected #{attr} on #{self} to be an Enumerable, got #{arr1.class}" unless arr1.is_a?(::Enumerable)
+        # @type [::Enumerable]
+        arr2 = other.send(attr)
+        raise "Expected #{attr} on #{other} to be an Enumerable, got #{arr2.class}" unless arr2.is_a?(::Enumerable)
+        return arr1 if arr1.count == arr2.count
+        Solargraph.assert_or_log("combine_with_#{attr}".to_sym,
+                                 "Inconsistent #{attr.inspect} count value between \nself =#{inspect} and \nother=#{other.inspect}:\n\n self.#{attr} = #{arr1.inspect}\nother.#{attr} = #{arr2.inspect}")
+        arr1
+      end
+
+      # @param other [self]
+      # @param attr [::Symbol]
+      #
+      # @return [Object, nil]
+      def assert_same(other, attr)
+        return false if other.nil?
+        val1 = send(attr)
+        val2 = other.send(attr)
+        return val1 if val1 == val2
+        Solargraph.assert_or_log("combine_with_#{attr}".to_sym,
+                                 "Inconsistent #{attr.inspect} values between \nself =#{inspect} and \nother=#{other.inspect}:\n\n self.#{attr} = #{val1.inspect}\nother.#{attr} = #{val2.inspect}")
+        val1
+      end
+
+      # @param other [self]
+      # @param attr [::Symbol]
+      # @sg-ignore
+      # @return [undefined]
+      def choose_pin_attr_with_same_name(other, attr)
+        # @type [Pin::Base, nil]
+        val1 = send(attr)
+        # @type [Pin::Base, nil]
+        val2 = other.send(attr)
+        raise "Expected pin for #{attr} on\n#{self.inspect},\ngot #{val1.inspect}" unless val1.nil? || val1.is_a?(Pin::Base)
+        raise "Expected pin for #{attr} on\n#{other.inspect},\ngot #{val2.inspect}" unless val2.nil? || val2.is_a?(Pin::Base)
+        if val1&.name != val2&.name
+          Solargraph.assert_or_log("combine_with_#{attr}_name".to_sym,
+                                   "Inconsistent #{attr.inspect} name values between \nself =#{inspect} and \nother=#{other.inspect}:\n\n self.#{attr} = #{val1.inspect}\nother.#{attr} = #{val2.inspect}")
+        end
+        choose_pin_attr(other, attr)
+      end
+
+      def choose_pin_attr(other, attr)
+        # @type [Pin::Base, nil]
+        val1 = send(attr)
+        # @type [Pin::Base, nil]
+        val2 = other.send(attr)
+        if val1.class != val2.class
+          Solargraph.assert_or_log("combine_with_#{attr}_class".to_sym,
+                                   "Inconsistent #{attr.inspect} class values between \nself =#{inspect} and \nother=#{other.inspect}:\n\n self.#{attr} = #{val1.inspect}\nother.#{attr} = #{val2.inspect}")
+          return val1
+        end
+        # arbitrary way of choosing a pin
+        [val1, val2].compact.min_by { _1.best_location.to_s }
+      end
+
+      def assert_source_provided
+        Solargraph.assert_or_log(:source, "source not provided - #{@path} #{@source} #{self.class}") if source.nil?
       end
 
       # @return [String]
@@ -71,15 +339,14 @@ module Solargraph
       # @param context_type [ComplexType] The receiver type
       # @return [self]
       def resolve_generics definitions, context_type
-        transformed = transform_types { |t| t.resolve_generics(definitions, context_type) if t }
-        transformed.erase_generics(definitions.generics)
+        transform_types { |t| t.resolve_generics(definitions, context_type) if t }
       end
 
       def all_rooted?
         !return_type || return_type.all_rooted?
       end
 
-      # @param generics_to_erase [Enumerable<String>]
+      # @param generics_to_erase [::Array<String>]
       # @return [self]
       def erase_generics(generics_to_erase)
         return self if generics_to_erase.empty?
@@ -103,7 +370,7 @@ module Solargraph
       end
 
       def to_s
-        to_rbs
+        desc
       end
 
       # @return [Boolean]
@@ -116,14 +383,6 @@ module Solargraph
         location || type_location
       end
 
-      # Pin equality is determined using the #nearly? method and also
-      # requiring both pins to have the same location.
-      #
-      def == other
-        return false unless nearly? other
-        comments == other.comments and location == other.location
-      end
-
       # True if the specified pin is a near match to this one. A near match
       # indicates that the pins contain mostly the same data. Any differences
       # between them should not have an impact on the API surface.
@@ -140,6 +399,15 @@ module Solargraph
           )
       end
 
+      # Pin equality is determined using the #nearly? method and also
+      # requiring both pins to have the same location.
+      #
+      # @param other [self]
+      def == other
+        return false unless nearly? other
+        comments == other.comments && location == other.location
+      end
+
       # The pin's return type.
       #
       # @return [ComplexType]
@@ -149,13 +417,13 @@ module Solargraph
 
       # @return [YARD::Docstring]
       def docstring
-        parse_comments unless defined?(@docstring)
+        parse_comments unless @docstring
         @docstring ||= Solargraph::Source.parse_docstring('').to_docstring
       end
 
       # @return [::Array<YARD::Tags::Directive>]
       def directives
-        parse_comments unless defined?(@directives)
+        parse_comments unless @directives
         @directives
       end
 
@@ -173,7 +441,7 @@ module Solargraph
       #
       # @return [Boolean]
       def maybe_directives?
-        return !@directives.empty? if defined?(@directives)
+        return !@directives.empty? if defined?(@directives) && @directives
         @maybe_directives ||= comments.include?('@!')
       end
 
@@ -212,26 +480,6 @@ module Solargraph
         probe api_map
       end
 
-      # Try to merge data from another pin. Merges are only possible if the
-      # pins are near matches (see the #nearly? method). The changes should
-      # not have any side effects on the API surface.
-      #
-      # @param pin [Pin::Base] The pin to merge into this one
-      # @return [Boolean] True if the pins were merged
-      def try_merge! pin
-        return false unless nearly?(pin)
-        @location = pin.location
-        @closure = pin.closure
-        return true if comments == pin.comments
-        @comments = pin.comments
-        @docstring = pin.docstring
-        @return_type = pin.return_type
-        @documentation = nil
-        @deprecated = nil
-        reset_conversions
-        true
-      end
-
       def proxied?
         @proxied ||= false
       end
@@ -266,9 +514,10 @@ module Solargraph
         result
       end
 
+      # @deprecated
       # @return [String]
       def identity
-        @identity ||= "#{closure.path}|#{name}"
+        @identity ||= "#{closure&.path}|#{name}|#{location}"
       end
 
       # @return [String, nil]
@@ -276,21 +525,51 @@ module Solargraph
         return_type.to_rbs
       end
 
-      # @return [String, nil]
-      def desc
+      # @return [String]
+      def type_desc
+        rbs = to_rbs
+        # RBS doesn't have a way to represent a Class<x> type
+        rbs = return_type.rooted_tags if return_type.name == 'Class'
         if path
-          if to_rbs
-            path + ' ' + to_rbs
+          if rbs
+            path + ' ' + rbs
           else
             path
           end
         else
-          to_rbs
+          rbs
         end
       end
 
+      # @return [String]
+      def inner_desc
+        closure_info = closure&.desc
+        binder_info = binder&.desc
+        "name=#{name.inspect} return_type=#{type_desc}, context=#{context.rooted_tags}, closure=#{closure_info}, binder=#{binder_info}"
+      end
+
+      def desc
+        "[#{inner_desc}]"
+      end
+
+      # @return [String]
       def inspect
-        "#<#{self.class} `#{self.desc}` at #{self.location.inspect}>"
+        "#<#{self.class} `#{self.inner_desc}`#{all_location_text} via #{source.inspect}>"
+      end
+
+      def all_location_text
+        if location.nil? && type_location.nil?
+          ''
+        elsif !location.nil? && type_location.nil?
+          " at #{location.inspect})"
+        elsif !type_location.nil? && location.nil?
+          " at #{type_location.inspect})"
+        else
+          " at (#{location.inspect} and #{type_location.inspect})"
+        end
+      end
+
+      def reset_generated!
       end
 
       protected
@@ -304,6 +583,10 @@ module Solargraph
       # @return [ComplexType]
       attr_writer :return_type
 
+      attr_writer :docstring
+
+      attr_writer :directives
+
       private
 
       # @return [void]

data/lib/solargraph/pin/base_variable.rb

@@ -11,12 +11,23 @@ module Solargraph
 
       attr_accessor :mass_assignment
 
+      # @param return_type [ComplexType, nil]
       # @param assignment [Parser::AST::Node, nil]
-      def initialize assignment: nil, **splat
+      def initialize assignment: nil, return_type: nil, **splat
         super(**splat)
         @assignment = assignment
         # @type [nil, ::Array(Parser::AST::Node, Integer)]
         @mass_assignment = nil
+        @return_type = return_type
+      end
+
+      def combine_with(other, attrs={})
+        attrs.merge({
+          assignment: assert_same(other, :assignment),
+          mass_assignment: assert_same(other, :mass_assignment),
+          return_type: combine_return_type(other),
+        })
+        super(other, attrs)
       end
 
       def completion_item_kind
@@ -32,7 +43,10 @@ module Solargraph
         @return_type ||= generate_complex_type
       end
 
+      # @sg-ignore
       def nil_assignment?
+        # this will always be false - should it be return_type ==
+        #   ComplexType::NIL or somesuch?
         return_type.nil?
       end
 
@@ -88,20 +102,14 @@ module Solargraph
         ComplexType::UNDEFINED
       end
 
+      # @param other [Object]
       def == other
         return false unless super
         assignment == other.assignment
       end
 
-      def try_merge! pin
-        return false unless super
-        @assignment = pin.assignment
-        @return_type = pin.return_type
-        true
-      end
-
-      def desc
-        "#{to_rbs} = #{assignment&.type.inspect}"
+      def type_desc
+        "#{super} = #{assignment&.type.inspect}"
       end
 
       private

data/lib/solargraph/pin/block.rb

@@ -3,6 +3,8 @@
 module Solargraph
   module Pin
     class Block < Callable
+      include Breakable
+
       # @return [Parser::AST::Node]
       attr_reader :receiver
 
@@ -36,14 +38,12 @@ module Solargraph
       #
       # @return [::Array<ComplexType>]
       def destructure_yield_types(yield_types, parameters)
-        return yield_types if yield_types.length == parameters.length
-
         # yielding a tuple into a block will destructure the tuple
         if yield_types.length == 1
           yield_type = yield_types.first
           return yield_type.all_params if yield_type.tuple? && yield_type.all_params.length == parameters.length
         end
-        parameters.map { ComplexType::UNDEFINED }
+        parameters.map.with_index { |_, idx| yield_types[idx] || ComplexType::UNDEFINED }
       end
 
       # @param api_map [ApiMap]

data/lib/solargraph/pin/breakable.rb

@@ -0,0 +1,9 @@
+module Solargraph
+  module Pin
+    # Mix-in for pins which enclose code which the 'break' statement works with-in - e.g., blocks, when, until, ...
+    module Breakable
+      # @return [Parser::AST::Node]
+      attr_reader :node
+    end
+  end
+end

data/lib/solargraph/pin/callable.rb

@@ -3,10 +3,10 @@
 module Solargraph
   module Pin
     class Callable < Closure
-      # @return [self]
+      # @return [Signature]
       attr_reader :block
 
-      attr_reader :parameters
+      attr_accessor :parameters
 
       # @return [ComplexType, nil]
       attr_reader :return_type
@@ -21,11 +21,67 @@ module Solargraph
         @parameters = parameters
       end
 
+      def method_namespace
+        closure.namespace
+      end
+
+      def combine_blocks(other)
+        if block.nil?
+          other.block
+        elsif other.block.nil?
+          block
+        else
+          choose_pin_attr(other, :block)
+        end
+      end
+
+      # @param other [self]
+      # @param attrs [Hash{Symbol => Object}]
+      #
+      # @return [self]
+      def combine_with(other, attrs={})
+        new_attrs = {
+          block: combine_blocks(other),
+          return_type: combine_return_type(other),
+        }.merge(attrs)
+        new_attrs[:parameters] = choose_parameters(other).clone.freeze unless new_attrs.key?(:parameters)
+        super(other, new_attrs)
+      end
+
       # @return [::Array<String>]
       def parameter_names
         @parameter_names ||= parameters.map(&:name)
       end
 
+      def generics
+        []
+      end
+
+      def choose_parameters(other)
+        raise "Trying to combine two pins with different arities - \nself =#{inspect}, \nother=#{other.inspect}, \n\n self.arity=#{self.arity}, \nother.arity=#{other.arity}" if other.arity != arity
+        parameters.zip(other.parameters).map do |param, other_param|
+          if param.nil? && other_param.block?
+            other_param
+          elsif other_param.nil? && param.block?
+            param
+          else
+            param.combine_with(other_param)
+          end
+        end
+      end
+
+      def blockless_parameters
+        if parameters.last&.block?
+          parameters[0..-2]
+        else
+          parameters
+        end
+      end
+
+      def arity
+        [generics, blockless_parameters.map(&:arity_decl), block&.arity]
+      end
+
       # @param generics_to_resolve [Enumerable<String>]
       # @param arg_types [Array<ComplexType>, nil]
       # @param return_type_context [ComplexType, nil]
@@ -57,7 +113,24 @@ module Solargraph
         callable
       end
 
-      # @param generics_to_resolve [Enumerable<String>]
+      def typify api_map
+        type = super
+        return type if type.defined?
+        if method_name.end_with?('?')
+          logger.debug { "Callable#typify(self=#{self}) => Boolean (? suffix)" }
+          ComplexType::BOOLEAN
+        else
+          logger.debug { "Callable#typify(self=#{self}) => undefined" }
+          ComplexType::UNDEFINED
+        end
+      end
+
+      def method_name
+        raise "closure was nil in #{self.inspect}" if closure.nil?
+        @method_name ||= closure.name
+      end
+
+      # @param generics_to_resolve [::Array<String>]
       # @param arg_types [Array<ComplexType>, nil]
       # @param return_type_context [ComplexType, nil]
       # @param yield_arg_types [Array<ComplexType>, nil]
@@ -113,7 +186,7 @@ module Solargraph
       end
 
       # @param arguments [::Array<Chain>]
-      # @param signature [Pin::Signature]
+      # @param with_block [Boolean]
       # @return [Boolean]
       def arity_matches? arguments, with_block
         argcount = arguments.length
@@ -140,8 +213,6 @@ module Solargraph
       protected
 
       attr_writer :block
-
-      attr_writer :parameters
     end
   end
 end