solargraph 0.59.0.dev.1 → 0.59.0.dev.2

data/lib/solargraph/pin/base.rb

@@ -46,7 +46,8 @@ module Solargraph
       # @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
@@ -60,7 +61,6 @@ module Solargraph
         # @type [ComplexType, ComplexType::UniqueType, nil]
         @binder = nil
 
-
         assert_source_provided
         assert_location_provided
       end
@@ -69,12 +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
+        unless @closure
+          Solargraph.assert_or_log(:closure,
+                                   "Closure not set on #{self.class} #{name.inspect} from #{source.inspect}")
+        end
         @closure
       end
 
@@ -82,7 +86,7 @@ module Solargraph
       # @param attrs [Hash{::Symbol => Object}]
       #
       # @return [self]
-      def combine_with(other, attrs={})
+      def combine_with other, attrs = {}
         priority_choice = choose_priority(other)
         return priority_choice unless priority_choice.nil?
 
@@ -101,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
@@ -110,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?
@@ -130,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]
@@ -143,22 +149,22 @@ module Solargraph
       # @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
       end
 
       # @param other [self]
       # @return [Pin::Closure, nil]
-      def combine_closure(other)
+      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
@@ -189,14 +195,9 @@ 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?
@@ -211,7 +212,9 @@ module Solargraph
           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
@@ -234,14 +237,17 @@ module Solargraph
       #
       # @sg-ignore
       # @return [undefined, nil]
-      def choose(other, attr)
+      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 }
+
+        # @sg-ignore Wrong argument type for Array#include?: object
+        #   expected Boolean, received Proc
+        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
 
@@ -249,7 +255,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
@@ -261,9 +267,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
@@ -278,8 +284,8 @@ module Solargraph
 
       # @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 }
@@ -289,7 +295,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, &block
         arr1 = send(attr)
         raise "Expected #{attr} on #{self} to be an Enumerable, got #{arr1.class}" unless arr1.is_a?(::Enumerable)
         # @type arr1 [::Enumerable]
@@ -303,7 +309,7 @@ module Solargraph
         values2 = arr2.map(&block)
         # @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
@@ -312,15 +318,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
@@ -330,16 +336,16 @@ module Solargraph
       #
       # @sg-ignore
       # @return [undefined]
-      def assert_same(other, attr)
+      def assert_same other, attr
         if other.nil?
-          Solargraph.assert_or_log("combine_with_#{attr}_nil".to_sym,
+          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
@@ -348,15 +354,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)
@@ -367,14 +375,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:
@@ -406,10 +414,9 @@ module Solargraph
 
       # @param generics_to_resolve [Enumerable<String>]
       # @param return_type_context [ComplexType, ComplexType::UniqueType, nil]
-      # @param context [ComplexType]
       # @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)
@@ -418,7 +425,7 @@ module Solargraph
       # @yieldparam [ComplexType]
       # @yieldreturn [ComplexType]
       # @return [self]
-      def transform_types(&transform)
+      def transform_types &transform
         proxy return_type.transform(&transform)
       end
 
@@ -430,7 +437,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?
@@ -439,7 +446,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
@@ -482,15 +489,18 @@ 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 ||
-            # @sg-ignore Translate to something flow sensitive typing understands
-            (((maybe_directives? == false && other.maybe_directives? == false) || compare_directives(directives, other.directives)) &&
+           # @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))
           )
@@ -573,7 +583,8 @@ module Solargraph
       # @param api_map [ApiMap]
       # @return [ComplexType, ComplexType::UniqueType]
       def infer api_map
-        Solargraph.assert_or_log(:pin_infer, '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
@@ -643,7 +654,7 @@ module Solargraph
         rbs = return_type.rooted_tags if return_type.name == 'Class'
         if path
           if rbs
-            path + ' ' + rbs
+            "#{path} #{rbs}"
           else
             path
           end
@@ -666,7 +677,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]
@@ -684,6 +695,11 @@ module Solargraph
 
       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
 
@@ -693,9 +709,7 @@ module Solargraph
       # @return [ComplexType, ComplexType::UniqueType, nil]
       attr_writer :return_type
 
-      attr_writer :docstring
-
-      attr_writer :directives
+      attr_writer :docstring, :directives
 
       private
 
@@ -717,13 +731,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
@@ -743,7 +757,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 &&
@@ -754,7 +768,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

data/lib/solargraph/pin/base_variable.rb

@@ -45,9 +45,9 @@ module Solargraph
       # @see https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#union-types
       # @see https://en.wikipedia.org/wiki/Intersection_type#TypeScript_example
       # @param presence [Range, nil]
-      # @param presence_certain [Boolean]
+      # @param [Hash{Symbol => Object}] splat
       def initialize assignment: nil, assignments: [], mass_assignment: nil,
-                     presence: nil, presence_certain: false, return_type: nil,
+                     presence: nil, return_type: nil,
                      intersection_return_type: nil, exclude_return_type: nil,
                      **splat
         super(**splat)
@@ -58,7 +58,6 @@ module Solargraph
         @intersection_return_type = intersection_return_type
         @exclude_return_type = exclude_return_type
         @presence = presence
-        @presence_certain = presence_certain
       end
 
       # @param presence [Range]
@@ -83,44 +82,33 @@ module Solargraph
         super
       end
 
-      def combine_with(other, attrs={})
+      def combine_with other, attrs = {}
         new_assignments = combine_assignments(other)
         new_attrs = attrs.merge({
-          # default values don't exist in RBS parameters; it just
-          # tells you if the arg is optional or not.  Prefer a
-          # provided value if we have one here since we can't rely on
-          # it from RBS so we can infer from it and typecheck on it.
-          assignment: choose(other, :assignment),
-          assignments: new_assignments,
-          mass_assignment: combine_mass_assignment(other),
-          return_type: combine_return_type(other),
-          intersection_return_type: combine_types(other, :intersection_return_type),
-          exclude_return_type: combine_types(other, :exclude_return_type),
-          presence: combine_presence(other),
-          presence_certain: combine_presence_certain(other)
-        })
+                                  # default values don't exist in RBS parameters; it just
+                                  # tells you if the arg is optional or not.  Prefer a
+                                  # provided value if we have one here since we can't rely on
+                                  # it from RBS so we can infer from it and typecheck on it.
+                                  assignment: choose(other, :assignment),
+                                  assignments: new_assignments,
+                                  mass_assignment: combine_mass_assignment(other),
+                                  return_type: combine_return_type(other),
+                                  intersection_return_type: combine_types(other, :intersection_return_type),
+                                  exclude_return_type: combine_types(other, :exclude_return_type),
+                                  presence: combine_presence(other)
+                                })
         super(other, new_attrs)
       end
 
       # @param other [self]
       #
       # @return [Array(AST::Node, Integer), nil]
-      def combine_mass_assignment(other)
+      def combine_mass_assignment other
         # @todo pick first non-nil arbitrarily - we don't yet support
         #   mass assignment merging
         mass_assignment || other.mass_assignment
       end
 
-      # If a certain pin is being combined with an uncertain pin, we
-      # end up with a certain result
-      #
-      # @param other [self]
-      #
-      # @return [Boolean]
-      def combine_presence_certain(other)
-        presence_certain? || other.presence_certain?
-      end
-
       # @return [Parser::AST::Node, nil]
       def assignment
         @assignment ||= assignments.last
@@ -129,7 +117,7 @@ module Solargraph
       # @param other [self]
       #
       # @return [::Array<Parser::AST::Node>]
-      def combine_assignments(other)
+      def combine_assignments other
         (other.assignments + assignments).uniq
       end
 
@@ -161,7 +149,7 @@ module Solargraph
       # @param parent_node [Parser::AST::Node]
       # @param api_map [ApiMap]
       # @return [::Array<ComplexType>]
-      def return_types_from_node(parent_node, api_map)
+      def return_types_from_node parent_node, api_map
         types = []
         value_position_nodes_only(parent_node).each do |node|
           # Nil nodes may not have a location
@@ -242,7 +230,7 @@ module Solargraph
 
       # @param other_loc [Location]
       # @sg-ignore flow sensitive typing needs to handle attrs
-      def starts_at?(other_loc)
+      def starts_at? other_loc
         location&.filename == other_loc.filename &&
           presence &&
           # @sg-ignore flow sensitive typing needs to handle attrs
@@ -254,7 +242,7 @@ module Solargraph
       # @param other [self]
       #
       # @return [Range, nil]
-      def combine_presence(other)
+      def combine_presence other
         return presence || other.presence if presence.nil? || other.presence.nil?
 
         # @sg-ignore flow sensitive typing needs to handle attrs
@@ -263,14 +251,14 @@ module Solargraph
 
       # @param other [self]
       # @return [Pin::Closure, nil]
-      def combine_closure(other)
-        return closure if self.closure == other.closure
+      def combine_closure other
+        return closure if closure == other.closure
 
         # choose first defined, as that establishes the scope of the variable
         if closure.nil? || other.closure.nil?
           Solargraph.assert_or_log(:varible_closure_missing) do
-            "One of the local variables being combined is missing a closure: " \
-              "#{self.inspect} vs #{other.inspect}"
+            'One of the local variables being combined is missing a closure: ' \
+              "#{inspect} vs #{other.inspect}"
           end
           return closure || other.closure
         end
@@ -290,7 +278,7 @@ module Solargraph
 
       # @param other_closure [Pin::Closure]
       # @param other_loc [Location]
-      def visible_at?(other_closure, other_loc)
+      def visible_at? other_closure, other_loc
         # @sg-ignore flow sensitive typing needs to handle attrs
         location.filename == other_loc.filename &&
           # @sg-ignore flow sensitive typing needs to handle attrs
@@ -298,10 +286,6 @@ module Solargraph
           visible_in_closure?(other_closure)
       end
 
-      def presence_certain?
-        @presence_certain
-      end
-
       protected
 
       attr_accessor :exclude_return_type, :intersection_return_type
@@ -315,40 +299,13 @@ module Solargraph
       # @param raw_return_type [ComplexType, ComplexType::UniqueType]
       #
       # @return [ComplexType, ComplexType::UniqueType]
-      def adjust_type(api_map, raw_return_type)
+      def adjust_type api_map, raw_return_type
         qualified_exclude = exclude_return_type&.qualify(api_map, *(closure&.gates || ['']))
         minus_exclusions = raw_return_type.exclude qualified_exclude, api_map
         qualified_intersection = intersection_return_type&.qualify(api_map, *(closure&.gates || ['']))
         minus_exclusions.intersect_with qualified_intersection, api_map
       end
 
-      # @param other [self]
-      # @return [Pin::Closure, nil]
-      def combine_closure(other)
-        return closure if self.closure == other.closure
-
-        # choose first defined, as that establishes the scope of the variable
-        if closure.nil? || other.closure.nil?
-          Solargraph.assert_or_log(:varible_closure_missing) do
-            "One of the local variables being combined is missing a closure: " \
-              "#{self.inspect} vs #{other.inspect}"
-          end
-          return closure || other.closure
-        end
-
-        # @sg-ignore Need to add nil check here
-        if closure.location.nil? || other.closure.location.nil?
-          # @sg-ignore Need to add nil check here
-          return closure.location.nil? ? other.closure : closure
-        end
-
-        # if filenames are different, this will just pick one
-        # @sg-ignore flow sensitive typing needs to handle attrs
-        return closure if closure.location <= other.closure.location
-
-        other.closure
-      end
-
       # See if this variable is visible within 'viewing_closure'
       #
       # @param viewing_closure [Pin::Closure]
@@ -381,7 +338,7 @@ module Solargraph
 
       # @param other [self]
       # @return [ComplexType, nil]
-      def combine_return_type(other)
+      def combine_return_type other
         combine_types(other, :return_type)
       end
 
@@ -389,7 +346,7 @@ module Solargraph
       # @param attr [::Symbol]
       #
       # @return [ComplexType, nil]
-      def combine_types(other, attr)
+      def combine_types other, attr
         # @type [ComplexType, nil]
         type1 = send(attr)
         # @type [ComplexType, nil]

data/lib/solargraph/pin/block.rb

@@ -15,6 +15,7 @@ module Solargraph
       # @param node [Parser::AST::Node, nil]
       # @param context [ComplexType, nil]
       # @param args [::Array<Parameter>]
+      # @param [Hash{Symbol => Object}] splat
       def initialize receiver: nil, args: [], context: nil, node: nil, **splat
         super(**splat, parameters: args)
         @receiver = receiver
@@ -44,7 +45,7 @@ module Solargraph
       # @param parameters [::Array<Parameter>]
       #
       # @return [::Array<ComplexType>]
-      def destructure_yield_types(yield_types, parameters)
+      def destructure_yield_types yield_types, parameters
         # yielding a tuple into a block will destructure the tuple
         if yield_types.length == 1
           yield_type = yield_types.first
@@ -55,7 +56,7 @@ module Solargraph
 
       # @param api_map [ApiMap]
       # @return [::Array<ComplexType>]
-      def typify_parameters(api_map)
+      def typify_parameters api_map
         chain = Parser.chain(receiver, filename, node)
         # @sg-ignore Need to add nil check here
         clip = api_map.clip_at(location.filename, location.range.start)

data/lib/solargraph/pin/breakable.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Solargraph
   module Pin
     # Mix-in for pins which enclose code which the 'break' statement