solargraph 0.58.3 → 0.59.2

data/lib/solargraph/pin/base.rb

@@ -41,12 +41,13 @@ module Solargraph
       # @param type_location [Solargraph::Location, nil]
       # @param closure [Solargraph::Pin::Closure, nil]
       # @param name [String]
-      # @param comments [String]
+      # @param comments [String, nil]
       # @param source [Symbol, nil]
       # @param docstring [YARD::Docstring, nil]
       # @param directives [::Array<YARD::Tags::Directive>, nil]
       # @param combine_priority [::Numeric, nil] See attr_reader for combine_priority
-      def initialize location: nil, type_location: nil, closure: nil, source: nil, name: '', comments: '', docstring: nil, directives: nil, combine_priority: nil
+      def initialize location: nil, type_location: nil, closure: nil, source: nil, name: '', comments: '',
+                     docstring: nil, directives: nil, combine_priority: nil
         @location = location
         @type_location = type_location
         @closure = closure
@@ -57,6 +58,8 @@ module Solargraph
         @docstring = docstring
         @directives = directives
         @combine_priority = combine_priority
+        # @type [ComplexType, ComplexType::UniqueType, nil]
+        @binder = nil
 
         assert_source_provided
         assert_location_provided
@@ -66,13 +69,16 @@ module Solargraph
       def assert_location_provided
         return unless best_location.nil? && %i[yardoc source rbs].include?(source)
 
-        Solargraph.assert_or_log(:best_location, "Neither location nor type_location provided - #{path} #{source} #{self.class}")
+        Solargraph.assert_or_log(:best_location,
+                                 "Neither location nor type_location provided - #{path} #{source} #{self.class}")
       end
 
       # @return [Pin::Closure, nil]
       def closure
-        Solargraph.assert_or_log(:closure, "Closure not set on #{self.class} #{name.inspect} from #{source.inspect}") unless @closure
-        # @type [Pin::Closure, nil]
+        unless @closure
+          Solargraph.assert_or_log(:closure,
+                                   "Closure not set on #{self.class} #{name.inspect} from #{source.inspect}")
+        end
         @closure
       end
 
@@ -80,8 +86,7 @@ module Solargraph
       # @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
+      def combine_with other, attrs = {}
         priority_choice = choose_priority(other)
         return priority_choice unless priority_choice.nil?
 
@@ -92,7 +97,7 @@ module Solargraph
           location: location,
           type_location: type_location,
           name: combined_name,
-          closure: choose_pin_attr_with_same_name(other, :closure),
+          closure: combine_closure(other),
           comments: choose_longer(other, :comments),
           source: :combined,
           docstring: choose(other, :docstring),
@@ -100,7 +105,9 @@ module Solargraph
           combine_priority: combine_priority
         }.merge(attrs)
         assert_same_macros(other)
-        logger.debug { "Base#combine_with(path=#{path}) - other.comments=#{other.comments.inspect}, self.comments = #{self.comments}" }
+        logger.debug do
+          "Base#combine_with(path=#{path}) - other.comments=#{other.comments.inspect}, self.comments = #{comments}"
+        end
         out = self.class.new(**new_attrs)
         out.reset_generated!
         out
@@ -109,7 +116,7 @@ module Solargraph
       # @param other [self]
       # @return [self, nil] Returns either the pin chosen based on priority or nil
       #   A nil return means that the combination process must proceed
-      def choose_priority(other)
+      def choose_priority other
         if combine_priority.nil? && !other.combine_priority.nil?
           return other
         elsif other.combine_priority.nil? && !combine_priority.nil?
@@ -129,7 +136,7 @@ module Solargraph
       # @param attr [::Symbol]
       # @sg-ignore
       # @return [undefined]
-      def choose_longer(other, attr)
+      def choose_longer other, attr
         # @type [undefined]
         val1 = send(attr)
         # @type [undefined]
@@ -140,16 +147,24 @@ module Solargraph
       end
 
       # @param other [self]
+      #
       # @return [::Array<YARD::Tags::Directive>, nil]
-      def combine_directives(other)
-        return self.directives if other.directives.empty?
+      def combine_directives other
+        return directives if other.directives.empty?
         return other.directives if directives.empty?
-        [directives + other.directives].uniq
+        (directives + other.directives).uniq
       end
 
       # @param other [self]
+      # @return [Pin::Closure, nil]
+      def combine_closure other
+        choose_pin_attr_with_same_name(other, :closure)
+      end
+
+      # @param other [self]
+      # @sg-ignore @type should override probed type
       # @return [String]
-      def combine_name(other)
+      def combine_name other
         if needs_consistent_name? || other.needs_consistent_name?
           assert_same(other, :name)
         else
@@ -170,6 +185,9 @@ module Solargraph
         # Same with @directives, @macros, @maybe_directives, which
         # regenerate docstring
         @deprecated = nil
+        @context = nil
+        @binder = nil
+        @path = nil
         reset_conversions
       end
 
@@ -177,25 +195,26 @@ module Solargraph
         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)
+      def combine_return_type other
         if return_type.undefined?
           other.return_type
         elsif other.return_type.undefined?
           return_type
+        elsif return_type.erased_version_of?(other.return_type)
+          other.return_type
+        elsif other.return_type.erased_version_of?(return_type)
+          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.reduce_class_type.rooted_tag }
+          if all_items.any?(&:selfy?) && all_items.any? do |item|
+            item.rooted_tag == context.reduce_class_type.rooted_tag
+          end
             # assume this was a declaration that should have said 'self'
             all_items.delete_if { |item| item.rooted_tag == context.reduce_class_type.rooted_tag }
           end
@@ -203,9 +222,12 @@ module Solargraph
         end
       end
 
+      # @sg-ignore need boolish support for ? methods
       def dodgy_return_type_source?
         # uses a lot of 'Object' instead of 'self'
-        location&.filename&.include?('core_ext/object/')
+        location&.filename&.include?('core_ext/object/') ||
+          # ditto
+          location&.filename&.include?('stdlib/date/0/date.rbs')
       end
 
       # when choices are arbitrary, make sure the choice is consistent
@@ -213,14 +235,17 @@ module Solargraph
       # @param other [Pin::Base]
       # @param attr [::Symbol]
       #
-      # @return [Object, nil]
-      def choose(other, attr)
+      # @sg-ignore
+      # @return [undefined, 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 }
+
+        return true if results.any? { |r| [true, false].include?(r) }
+        return results.first if results.any? { |r| r.is_a? AST::Node }
         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}")
+      rescue StandardError
+        warn("Problem handling #{attr} for \n#{inspect}\n and \n#{other.inspect}\n\n#{send(attr).inspect} vs #{other.send(attr).inspect}")
         raise
       end
 
@@ -228,7 +253,7 @@ module Solargraph
       # @param attr [::Symbol]
       # @sg-ignore
       # @return [undefined]
-      def choose_node(other, attr)
+      def choose_node other, attr
         if other.object_id < attr.object_id
           other.send(attr)
         else
@@ -240,9 +265,9 @@ module Solargraph
       # @param attr [::Symbol]
       # @sg-ignore
       # @return [undefined]
-      def prefer_rbs_location(other, attr)
+      def prefer_rbs_location other, attr
         if rbs_location? && !other.rbs_location?
-          self.send(attr)
+          send(attr)
         elsif !rbs_location? && other.rbs_location?
           other.send(attr)
         else
@@ -250,14 +275,15 @@ module Solargraph
         end
       end
 
+      # @sg-ignore need boolish support for ? methods
       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
+      def assert_same_macros other
+        return unless source == :yardoc && other.source == :yardoc
         assert_same_count(other, :macros)
         # @param [YARD::Tags::MacroDirective]
         assert_same_array_content(other, :macros) { |macro| macro.tag.name }
@@ -267,7 +293,7 @@ module Solargraph
       # @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)
+      def assert_same_array_content(other, attr, &)
         arr1 = send(attr)
         raise "Expected #{attr} on #{self} to be an Enumerable, got #{arr1.class}" unless arr1.is_a?(::Enumerable)
         # @type arr1 [::Enumerable]
@@ -276,12 +302,12 @@ module Solargraph
         # @type arr2 [::Enumerable]
 
         # @type [undefined]
-        values1 = arr1.map(&block)
+        values1 = arr1.map(&)
         # @type [undefined]
-        values2 = arr2.map(&block)
+        values2 = arr2.map(&)
         # @sg-ignore
         return arr1 if values1 == values2
-        Solargraph.assert_or_log("combine_with_#{attr}".to_sym,
+        Solargraph.assert_or_log(:"combine_with_#{attr}",
                                  "Inconsistent #{attr.inspect} values between \nself =#{inspect} and \nother=#{other.inspect}:\n\n self values = #{values1}\nother values =#{attr} = #{values2}")
         arr1
       end
@@ -290,15 +316,15 @@ module Solargraph
       # @param attr [::Symbol]
       #
       # @return [::Enumerable]
-      def assert_same_count(other, attr)
+      def assert_same_count other, attr
         # @type [::Enumerable]
-        arr1 = self.send(attr)
+        arr1 = 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,
+        Solargraph.assert_or_log(:"combine_with_#{attr}",
                                  "Inconsistent #{attr.inspect} count value between \nself =#{inspect} and \nother=#{other.inspect}:\n\n self.#{attr} = #{arr1.inspect}\nother.#{attr} = #{arr2.inspect}")
         arr1
       end
@@ -308,12 +334,16 @@ module Solargraph
       #
       # @sg-ignore
       # @return [undefined]
-      def assert_same(other, attr)
-        return false if other.nil?
+      def assert_same other, attr
+        if other.nil?
+          Solargraph.assert_or_log(:"combine_with_#{attr}_nil",
+                                   "Other was passed in nil in assert_same on #{self}")
+          return send(attr)
+        end
         val1 = send(attr)
         val2 = other.send(attr)
         return val1 if val1 == val2
-        Solargraph.assert_or_log("combine_with_#{attr}".to_sym,
+        Solargraph.assert_or_log(:"combine_with_#{attr}",
                                  "Inconsistent #{attr.inspect} values between \nself =#{inspect} and \nother=#{other.inspect}:\n\n self.#{attr} = #{val1.inspect}\nother.#{attr} = #{val2.inspect}")
         val1
       end
@@ -322,15 +352,17 @@ module Solargraph
       # @param attr [::Symbol]
       # @sg-ignore
       # @return [undefined]
-      def choose_pin_attr_with_same_name(other, attr)
+      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)
+        raise "Expected pin for #{attr} on\n#{inspect},\ngot #{val1.inspect}" unless val1.nil? || val1.is_a?(Pin::Base)
+        unless val2.nil? || val2.is_a?(Pin::Base)
+          raise "Expected pin for #{attr} on\n#{other.inspect},\ngot #{val2.inspect}"
+        end
         if val1&.name != val2&.name
-          Solargraph.assert_or_log("combine_with_#{attr}_name".to_sym,
+          Solargraph.assert_or_log(:"combine_with_#{attr}_name",
                                    "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)
@@ -341,14 +373,14 @@ module Solargraph
       #
       # @sg-ignore Missing @return tag for Solargraph::Pin::Base#choose_pin_attr
       # @return [undefined]
-      def choose_pin_attr(other, attr)
+      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
           # :nocov:
-          Solargraph.assert_or_log("combine_with_#{attr}_class".to_sym,
+          Solargraph.assert_or_log(:"combine_with_#{attr}_class",
                                    "Inconsistent #{attr.inspect} class values between \nself =#{inspect} and \nother=#{other.inspect}:\n\n self.#{attr} = #{val1.inspect}\nother.#{attr} = #{val2.inspect}")
           return val1
           # :nocov:
@@ -358,8 +390,11 @@ module Solargraph
           [
             # maximize number of gates, as types in other combined pins may
             # depend on those gates
+
+            # @sg-ignore Need better handling of #compact
             closure.gates.length,
             # use basename so that results don't vary system to system
+            # @sg-ignore Need better handling of #compact
             File.basename(closure.best_location.to_s)
           ]
         end
@@ -376,11 +411,10 @@ module Solargraph
       end
 
       # @param generics_to_resolve [Enumerable<String>]
-      # @param return_type_context [ComplexType, nil]
-      # @param context [ComplexType]
+      # @param return_type_context [ComplexType, ComplexType::UniqueType, nil]
       # @param resolved_generic_values [Hash{String => ComplexType}]
       # @return [self]
-      def resolve_generics_from_context(generics_to_resolve, return_type_context = nil, resolved_generic_values: {})
+      def resolve_generics_from_context generics_to_resolve, return_type_context = nil, resolved_generic_values: {}
         proxy return_type.resolve_generics_from_context(generics_to_resolve,
                                                         return_type_context,
                                                         resolved_generic_values: resolved_generic_values)
@@ -389,7 +423,7 @@ module Solargraph
       # @yieldparam [ComplexType]
       # @yieldreturn [ComplexType]
       # @return [self]
-      def transform_types(&transform)
+      def transform_types &transform
         proxy return_type.transform(&transform)
       end
 
@@ -401,7 +435,7 @@ module Solargraph
       # @param context_type [ComplexType] The receiver type
       # @return [self]
       def resolve_generics definitions, context_type
-        transform_types { |t| t.resolve_generics(definitions, context_type) if t }
+        transform_types { |t| t&.resolve_generics(definitions, context_type) }
       end
 
       def all_rooted?
@@ -410,7 +444,7 @@ module Solargraph
 
       # @param generics_to_erase [::Array<String>]
       # @return [self]
-      def erase_generics(generics_to_erase)
+      def erase_generics generics_to_erase
         return self if generics_to_erase.empty?
         transform_types { |t| t.erase_generics(generics_to_erase) }
       end
@@ -418,6 +452,7 @@ module Solargraph
       # @return [String, nil]
       def filename
         return nil if location.nil?
+        # @sg-ignore flow sensitive typing needs to handle attrs
         location.filename
       end
 
@@ -452,12 +487,20 @@ module Solargraph
       # @param other [Solargraph::Pin::Base, Object]
       # @return [Boolean]
       def nearly? other
-        self.class == other.class &&
+        instance_of?(other.class) &&
+          # @sg-ignore Translate to something flow sensitive typing understands
           name == other.name &&
+          # @sg-ignore flow sensitive typing needs to handle attrs
           (closure == other.closure || (closure && closure.nearly?(other.closure))) &&
+          # @sg-ignore Translate to something flow sensitive typing understands
           (comments == other.comments ||
-            (((maybe_directives? == false && other.maybe_directives? == false) || compare_directives(directives, other.directives)) &&
-            compare_docstring_tags(docstring, other.docstring))
+           # @sg-ignore Translate to something flow sensitive typing understands
+           (((maybe_directives? == false && other.maybe_directives? == false) ||
+             compare_directives(directives,
+                                # @sg-ignore Translate to something flow sensitive typing understands
+                                other.directives)) &&
+             # @sg-ignore Translate to something flow sensitive typing understands
+             compare_docstring_tags(docstring, other.docstring))
           )
       end
 
@@ -484,6 +527,7 @@ module Solargraph
         @docstring ||= Solargraph::Source.parse_docstring('').to_docstring
       end
 
+      # @sg-ignore parse_comments will always set @directives
       # @return [::Array<YARD::Tags::Directive>]
       def directives
         parse_comments unless @directives
@@ -520,7 +564,7 @@ module Solargraph
       # provided ApiMap.
       #
       # @param api_map [ApiMap]
-      # @return [ComplexType]
+      # @return [ComplexType, ComplexType::UniqueType]
       def typify api_map
         return_type.qualify(api_map, *(closure&.gates || ['']))
       end
@@ -528,16 +572,17 @@ module Solargraph
       # Infer the pin's return type via static code analysis.
       #
       # @param api_map [ApiMap]
-      # @return [ComplexType]
+      # @return [ComplexType, ComplexType::UniqueType]
       def probe api_map
         typify api_map
       end
 
       # @deprecated Use #typify and/or #probe instead
       # @param api_map [ApiMap]
-      # @return [ComplexType]
+      # @return [ComplexType, ComplexType::UniqueType]
       def infer api_map
-        Solargraph::Logging.logger.warn "WARNING: Pin #infer methods are deprecated. Use #typify or #probe instead."
+        Solargraph.assert_or_log(:pin_infer,
+                                 'WARNING: Pin #infer methods are deprecated. Use #typify or #probe instead.')
         type = typify(api_map)
         return type unless type.undefined?
         probe api_map
@@ -568,7 +613,7 @@ module Solargraph
       # the return type and the #proxied? setting, the proxy should be a clone
       # of the original.
       #
-      # @param return_type [ComplexType]
+      # @param return_type [ComplexType, ComplexType::UniqueType, nil]
       # @return [self]
       def proxy return_type
         result = dup
@@ -607,7 +652,7 @@ module Solargraph
         rbs = return_type.rooted_tags if return_type.name == 'Class'
         if path
           if rbs
-            path + ' ' + rbs
+            "#{path} #{rbs}"
           else
             path
           end
@@ -618,7 +663,7 @@ module Solargraph
 
       # @return [String]
       def inner_desc
-        closure_info = closure&.desc
+        closure_info = closure&.name.inspect
         binder_info = binder&.desc
         "name=#{name.inspect} return_type=#{type_desc}, context=#{context.rooted_tags}, closure=#{closure_info}, binder=#{binder_info}"
       end
@@ -630,7 +675,7 @@ module Solargraph
 
       # @return [String]
       def inspect
-        "#<#{self.class} `#{self.inner_desc}`#{all_location_text} via #{source.inspect}>"
+        "#<#{self.class} `#{inner_desc}`#{all_location_text} via #{source.inspect}>"
       end
 
       # @return [String]
@@ -646,24 +691,23 @@ module Solargraph
         end
       end
 
-      # @return [void]
-      def reset_generated!
-      end
-
       protected
 
+      # @sg-ignore def should infer as symbol - "Not enough arguments to Module#protected"
+      def equality_fields
+        [name, location, type_location, closure, source]
+      end
+
       # @return [Boolean]
       attr_writer :probed
 
       # @return [Boolean]
       attr_writer :proxied
 
-      # @return [ComplexType]
+      # @return [ComplexType, ComplexType::UniqueType, nil]
       attr_writer :return_type
 
-      attr_writer :docstring
-
-      attr_writer :directives
+      attr_writer :docstring, :directives
 
       private
 
@@ -685,13 +729,13 @@ module Solargraph
       # True if two docstrings have the same tags, regardless of any other
       # differences.
       #
-      # @param d1 [YARD::Docstring]
-      # @param d2 [YARD::Docstring]
+      # @param docstring1 [YARD::Docstring]
+      # @param docstring2 [YARD::Docstring]
       # @return [Boolean]
-      def compare_docstring_tags d1, d2
-        return false if d1.tags.length != d2.tags.length
-        d1.tags.each_index do |i|
-          return false unless compare_tags(d1.tags[i], d2.tags[i])
+      def compare_docstring_tags docstring1, docstring2
+        return false if docstring1.tags.length != docstring2.tags.length
+        docstring1.tags.each_index do |i|
+          return false unless compare_tags(docstring1.tags[i], docstring2.tags[i])
         end
         true
       end
@@ -711,7 +755,7 @@ module Solargraph
       # @param tag2 [YARD::Tags::Tag]
       # @return [Boolean]
       def compare_tags tag1, tag2
-        tag1.class == tag2.class &&
+        tag1.instance_of?(tag2.class) &&
           tag1.tag_name == tag2.tag_name &&
           tag1.text == tag2.text &&
           tag1.name == tag2.name &&
@@ -722,7 +766,7 @@ module Solargraph
       def collect_macros
         return [] unless maybe_directives?
         parse = Solargraph::Source.parse_docstring(comments)
-        parse.directives.select{ |d| d.tag.tag_name == 'macro' }
+        parse.directives.select { |d| d.tag.tag_name == 'macro' }
       end
     end
   end