solargraph 0.56.0 → 0.57.0

data/lib/solargraph/parser/parser_gem/node_methods.rb

@@ -120,7 +120,7 @@ module Solargraph
         end
 
         # @param node [Parser::AST::Node]
-        # @return [Hash{Parser::AST::Node => Chain}]
+        # @return [Hash{Symbol => Chain}]
         def convert_hash node
           return {} unless Parser.is_ast_node?(node)
           return convert_hash(node.children[0]) if node.type == :kwsplat
@@ -179,6 +179,7 @@ module Solargraph
             node.children[1..-1].each { |child| result.concat call_nodes_from(child) }
           elsif node.type == :send
             result.push node
+            result.concat call_nodes_from(node.children.first)
             node.children[2..-1].each { |child| result.concat call_nodes_from(child) }
           elsif [:super, :zsuper].include?(node.type)
             result.push node
@@ -232,6 +233,7 @@ module Solargraph
           else
             source.tree_at(position.line, position.column - 1)
           end
+          # @type [AST::Node, nil]
           prev = nil
           tree.each do |node|
             if node.type == :send
@@ -242,7 +244,7 @@ module Solargraph
                 if source.synchronized?
                   return node if source.code[0..offset-1] =~ /\(\s*\z/ && source.code[offset..-1] =~ /^\s*\)/
                 else
-                  return node if source.code[0..offset-1] =~ /\([^\(]*\z/
+                  return node if source.code[0..offset-1] =~ /\([^(]*\z/
                 end
               end
             end

data/lib/solargraph/parser/parser_gem/node_processors/block_node.rb

@@ -19,7 +19,7 @@ module Solargraph
             else
               region.closure
             end
-            pins.push Solargraph::Pin::Block.new(
+            block_pin = Solargraph::Pin::Block.new(
               location: location,
               closure: parent,
               node: node,
@@ -28,7 +28,8 @@ module Solargraph
               scope: region.scope || region.closure.context.scope,
               source: :parser
             )
-            process_children region.update(closure: pins.last)
+            pins.push block_pin
+            process_children region.update(closure: block_pin)
           end
 
           private

data/lib/solargraph/parser/parser_gem/node_processors/casgn_node.rb

@@ -8,17 +8,6 @@ module Solargraph
           include ParserGem::NodeMethods
 
           def process
-            if Convention::StructDefinition::StructAssignmentNode.valid?(node)
-              process_struct_assignment
-            else
-              process_constant_assignment
-            end
-          end
-
-          private
-
-          # @return [void]
-          def process_constant_assignment
             pins.push Solargraph::Pin::Constant.new(
               location: get_node_location(node),
               closure: region.closure,
@@ -30,16 +19,7 @@ module Solargraph
             process_children
           end
 
-          # @todo Move this out of [CasgnNode] once [Solargraph::Parser::NodeProcessor] supports
-          #   multiple processors.
-          def process_struct_assignment
-            processor_klass = Convention::StructDefinition::NodeProcessors::StructNode
-            processor = processor_klass.new(node, region, pins, locals)
-            processor.process
-
-            @pins = processor.pins
-            @locals = processor.locals
-          end
+          private
 
           # @return [String]
           def const_name

data/lib/solargraph/parser/parser_gem/node_processors/if_node.rb

@@ -11,6 +11,8 @@ module Solargraph
             process_children
 
             position = get_node_start_position(node)
+            # @sg-ignore
+            # @type [Solargraph::Pin::Breakable, nil]
             enclosing_breakable_pin = pins.select{|pin| pin.is_a?(Pin::Breakable) && pin.location.range.contain?(position)}.last
             FlowSensitiveTyping.new(locals, enclosing_breakable_pin).process_if(node)
           end

data/lib/solargraph/parser/parser_gem/node_processors/masgn_node.rb

@@ -7,6 +7,7 @@ module Solargraph
         class MasgnNode < Parser::NodeProcessor::Base
           include ParserGem::NodeMethods
 
+          # @return [void]
           def process
             # Example:
             #
@@ -21,8 +22,11 @@ module Solargraph
             #     s(:int, 2),
             #     s(:int, 3)))
             masgn = node
+            # @type [Parser::AST::Node]
             mlhs = masgn.children.fetch(0)
+            # @type [Array<Parser::AST::Node>]
             lhs_arr = mlhs.children
+            # @type [Parser::AST::Node]
             mass_rhs = node.children.fetch(1)
 
             # Get pins created for the mlhs node
@@ -40,7 +44,9 @@ module Solargraph
               # @todo in line below, nothing in typechecking alerts
               #   when a non-existant method is called on 'l'
               if pin.nil?
-                Solargraph.logger.debug { "Could not find local for masgn= value in location #{location.inspect} in #{lhs_arr} - masgn = #{masgn}, lhs.type = #{lhs.type}" }
+                Solargraph.logger.debug do
+                  "Could not find local for masgn= value in location #{location.inspect} in #{lhs_arr} - masgn = #{masgn}, lhs.type = #{lhs.type}"
+                end
                 next
               end
               pin.mass_assignment = [mass_rhs, i]

data/lib/solargraph/parser/parser_gem/node_processors/namespace_node.rb

@@ -11,17 +11,6 @@ module Solargraph
             superclass_name = nil
             superclass_name = unpack_name(node.children[1]) if node.type == :class && node.children[1]&.type == :const
 
-            if Convention::StructDefinition::StructDefintionNode.valid?(node)
-              process_struct_definition
-            else
-              process_namespace(superclass_name)
-            end
-          end
-
-          private
-
-          # @param superclass_name [String, nil]
-          def process_namespace(superclass_name)
             loc = get_node_location(node)
             nspin = Solargraph::Pin::Namespace.new(
               type: node.type,
@@ -44,17 +33,6 @@ module Solargraph
             end
             process_children region.update(closure: nspin, visibility: :public)
           end
-
-          # @todo Move this out of [NamespaceNode] once [Solargraph::Parser::NodeProcessor] supports
-          #   multiple processors.
-          def process_struct_definition
-            processor_klass = Convention::StructDefinition::NodeProcessors::StructNode
-            processor = processor_klass.new(node, region, pins, locals)
-            processor.process
-
-            @pins = processor.pins
-            @locals = processor.locals
-          end
         end
       end
     end

data/lib/solargraph/parser/parser_gem/node_processors/opasgn_node.rb

@@ -7,6 +7,7 @@ module Solargraph
     module ParserGem
       module NodeProcessors
         class OpasgnNode < Parser::NodeProcessor::Base
+          # @return [void]
           def process
             # Parser::CurrentRuby.parse("a += 2")
             # => s(:op_asgn,

data/lib/solargraph/parser/parser_gem/node_processors/orasgn_node.rb

@@ -5,6 +5,7 @@ module Solargraph
     module ParserGem
       module NodeProcessors
         class OrasgnNode < Parser::NodeProcessor::Base
+          # @return [void]
           def process
             new_node = node.updated(node.children[0].type, node.children[0].children + [node.children[1]])
             NodeProcessor.process(new_node, region, pins, locals)

data/lib/solargraph/parser/parser_gem/node_processors/resbody_node.rb

@@ -7,6 +7,7 @@ module Solargraph
         class ResbodyNode < Parser::NodeProcessor::Base
           include ParserGem::NodeMethods
 
+          # @return [void]
           def process
             if node.children[1] # Exception local variable name
               here = get_node_start_position(node.children[1])

data/lib/solargraph/parser/parser_gem/node_processors/send_node.rb

@@ -8,32 +8,44 @@ module Solargraph
           include ParserGem::NodeMethods
 
           def process
+            # @sg-ignore Variable type could not be inferred for method_name
+            # @type [Symbol]
+            method_name = node.children[1]
+            # :nocov:
+            unless method_name.instance_of?(Symbol)
+              Solargraph.assert_or_log(:parser_method_name, "Expected method name to be a Symbol, got #{method_name.class} for node #{node.inspect}")
+              return process_children
+            end
+            # :nocov:
             if node.children[0].nil?
-              if [:private, :public, :protected].include?(node.children[1])
+              if [:private, :public, :protected].include?(method_name)
                 process_visibility
-              elsif node.children[1] == :module_function
+              elsif method_name == :module_function
                 process_module_function
-              elsif [:attr_reader, :attr_writer, :attr_accessor].include?(node.children[1])
+              elsif [:attr_reader, :attr_writer, :attr_accessor].include?(method_name)
                 process_attribute
-              elsif node.children[1] == :include
+              elsif method_name == :include
                 process_include
-              elsif node.children[1] == :extend
+              elsif method_name == :extend
                 process_extend
-              elsif node.children[1] == :prepend
+              elsif method_name == :prepend
                 process_prepend
-              elsif node.children[1] == :require
+              elsif method_name == :require
                 process_require
-              elsif node.children[1] == :autoload
+              elsif method_name == :autoload
                 process_autoload
-              elsif node.children[1] == :private_constant
+              elsif method_name == :private_constant
                 process_private_constant
-              elsif node.children[1] == :alias_method && node.children[2] && node.children[2] && node.children[2].type == :sym && node.children[3] && node.children[3].type == :sym
+              # @sg-ignore
+              elsif method_name == :alias_method && node.children[2] && node.children[2] && node.children[2].type == :sym && node.children[3] && node.children[3].type == :sym
                 process_alias_method
-              elsif node.children[1] == :private_class_method && node.children[2].is_a?(AST::Node)
+              # @sg-ignore
+              elsif method_name == :private_class_method && node.children[2].is_a?(AST::Node)
                 # Processing a private class can potentially handle children on its own
                 return if process_private_class_method
               end
-            elsif node.children[1] == :require && node.children[0].to_s == '(const nil :Bundler)'
+            # @sg-ignore
+            elsif method_name == :require && node.children[0].to_s == '(const nil :Bundler)'
               pins.push Pin::Reference::Require.new(Solargraph::Location.new(region.filename, Solargraph::Range.from_to(0, 0, 0, 0)), 'bundler/require', source: :parser)
             end
             process_children
@@ -45,15 +57,24 @@ module Solargraph
           def process_visibility
             if (node.children.length > 2)
               node.children[2..-1].each do |child|
+                # @sg-ignore Variable type could not be inferred for method_name
+                # @type [Symbol]
+                visibility = node.children[1]
+                # :nocov:
+                unless visibility.instance_of?(Symbol)
+                  Solargraph.assert_or_log(:parser_visibility, "Expected visibility name to be a Symbol, got #{visibility.class} for node #{node.inspect}")
+                  return process_children
+                end
+                # :nocov:
                 if child.is_a?(AST::Node) && (child.type == :sym || child.type == :str)
                   name = child.children[0].to_s
                   matches = pins.select{ |pin| pin.is_a?(Pin::Method) && pin.name == name && pin.namespace == region.closure.full_context.namespace && pin.context.scope == (region.scope || :instance)}
                   matches.each do |pin|
                     # @todo Smelly instance variable access
-                    pin.instance_variable_set(:@visibility, node.children[1])
+                    pin.instance_variable_set(:@visibility, visibility)
                   end
                 else
-                  process_children region.update(visibility: node.children[1])
+                  process_children region.update(visibility: visibility)
                 end
               end
             else

data/lib/solargraph/parser/parser_gem/node_processors/sym_node.rb

@@ -5,6 +5,7 @@ module Solargraph
     module ParserGem
       module NodeProcessors
         class SymNode < Parser::NodeProcessor::Base
+          # @return [void]
           def process
             pins.push Solargraph::Pin::Symbol.new(
               get_node_location(node),

data/lib/solargraph/parser/parser_gem/node_processors.rb

@@ -42,6 +42,8 @@ module Solargraph
       register :defs,         ParserGem::NodeProcessors::DefsNode
       register :if,           ParserGem::NodeProcessors::IfNode
       register :send,         ParserGem::NodeProcessors::SendNode
+      register :class,        Convention::StructDefinition::NodeProcessors::StructNode
+      register :class,        Convention::DataDefinition::NodeProcessors::DataNode
       register :class,        ParserGem::NodeProcessors::NamespaceNode
       register :module,       ParserGem::NodeProcessors::NamespaceNode
       register :sclass,       ParserGem::NodeProcessors::SclassNode
@@ -49,6 +51,8 @@ module Solargraph
       register :cvasgn,       ParserGem::NodeProcessors::CvasgnNode
       register :lvasgn,       ParserGem::NodeProcessors::LvasgnNode
       register :gvasgn,       ParserGem::NodeProcessors::GvasgnNode
+      register :casgn,        Convention::StructDefinition::NodeProcessors::StructNode
+      register :casgn,        Convention::DataDefinition::NodeProcessors::DataNode
       register :casgn,        ParserGem::NodeProcessors::CasgnNode
       register :masgn,        ParserGem::NodeProcessors::MasgnNode
       register :alias,        ParserGem::NodeProcessors::AliasNode

data/lib/solargraph/parser/region.rb

@@ -23,8 +23,10 @@ module Solargraph
 
       # @param source [Source]
       # @param namespace [String]
+      # @param closure [Pin::Closure, nil]
       # @param scope [Symbol, nil]
       # @param visibility [Symbol]
+      # @param lvars [Array<Symbol>]
       def initialize source: Solargraph::Source.load_string(''), closure: nil,
                      scope: nil, visibility: :public, lvars: []
         @source = source
@@ -45,6 +47,7 @@ module Solargraph
       # @param closure [Pin::Closure, nil]
       # @param scope [Symbol, nil]
       # @param visibility [Symbol, nil]
+      # @param lvars [Array<Symbol>, nil]
       # @return [Region]
       def update closure: nil, scope: nil, visibility: nil, lvars: nil
         Region.new(

data/lib/solargraph/parser/snippet.rb

@@ -6,6 +6,8 @@ module Solargraph
       # @return [String]
       attr_reader :text
 
+      # @param range [Solargraph::Range]
+      # @param text [String]
       def initialize range, text
         @range = range
         @text = text

data/lib/solargraph/pin/base.rb

@@ -13,10 +13,10 @@ module Solargraph
       # @return [YARD::CodeObjects::Base]
       attr_reader :code_object
 
-      # @return [Solargraph::Location]
+      # @return [Solargraph::Location, nil]
       attr_reader :location
 
-      # @return [Solargraph::Location]
+      # @return [Solargraph::Location, nil]
       attr_reader :type_location
 
       # @return [String]
@@ -28,6 +28,11 @@ module Solargraph
       # @return [::Symbol]
       attr_accessor :source
 
+      # @type [::Numeric, nil] A priority for determining if pins should be combined or not
+      #   A nil priority is considered the be the lowest. All code, yard & rbs pins have nil priority
+      #   Between 2 pins, the one with the higher priority gets chosen. If the priorities are equal, they are combined.
+      attr_reader :combine_priority
+
       def presence_certain?
         true
       end
@@ -40,7 +45,8 @@ module Solargraph
       # @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
+      # @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
         @location = location
         @type_location = type_location
         @closure = closure
@@ -50,15 +56,35 @@ module Solargraph
         @identity = nil
         @docstring = docstring
         @directives = directives
+        @combine_priority = combine_priority
+
         assert_source_provided
+        assert_location_provided
+      end
+
+      # @return [void]
+      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}")
+      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]
+        @closure
       end
 
       # @param other [self]
-      # @param attrs [Hash{Symbol => Object}]
+      # @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
+        priority_choice = choose_priority(other)
+        return priority_choice unless priority_choice.nil?
+
         type_location = choose(other, :type_location)
         location = choose(other, :location)
         combined_name = combine_name(other)
@@ -71,6 +97,7 @@ module Solargraph
           source: :combined,
           docstring: choose(other, :docstring),
           directives: combine_directives(other),
+          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}" }
@@ -79,6 +106,25 @@ module Solargraph
         out
       end
 
+      # @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)
+        if combine_priority.nil? && !other.combine_priority.nil?
+          return other
+        elsif other.combine_priority.nil? && !combine_priority.nil?
+          return self
+        elsif !combine_priority.nil? && !other.combine_priority.nil?
+          if combine_priority > other.combine_priority
+            return self
+          elsif combine_priority < other.combine_priority
+            return other
+          end
+        end
+
+        nil
+      end
+
       # @param other [self]
       # @param attr [::Symbol]
       # @sg-ignore
@@ -90,7 +136,6 @@ module Solargraph
         val2 = other.send(attr)
         return val1 if val1 == val2
         return val2 if val1.nil?
-        # @sg-ignore
         val1.length > val2.length ? val1 : val2
       end
 
@@ -180,7 +225,7 @@ module Solargraph
       end
 
       # @param other [self]
-      # @param attr [Symbol]
+      # @param attr [::Symbol]
       # @sg-ignore
       # @return [undefined]
       def choose_node(other, attr)
@@ -229,7 +274,6 @@ module Solargraph
         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]
@@ -261,7 +305,8 @@ module Solargraph
       # @param other [self]
       # @param attr [::Symbol]
       #
-      # @return [Object, nil]
+      # @sg-ignore
+      # @return [undefined]
       def assert_same(other, attr)
         return false if other.nil?
         val1 = send(attr)
@@ -290,20 +335,29 @@ module Solargraph
         choose_pin_attr(other, attr)
       end
 
+      # @param other [self]
+      # @param attr [::Symbol]
+      #
+      # @sg-ignore
+      # @return [undefined]
       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,
                                    "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:
         end
         # arbitrary way of choosing a pin
+        # @sg-ignore Need _1 support
         [val1, val2].compact.min_by { _1.best_location.to_s }
       end
 
+      # @return [void]
       def assert_source_provided
         Solargraph.assert_or_log(:source, "source not provided - #{@path} #{@source} #{self.class}") if source.nil?
       end
@@ -548,6 +602,7 @@ module Solargraph
         "name=#{name.inspect} return_type=#{type_desc}, context=#{context.rooted_tags}, closure=#{closure_info}, binder=#{binder_info}"
       end
 
+      # @return [String]
       def desc
         "[#{inner_desc}]"
       end
@@ -557,6 +612,7 @@ module Solargraph
         "#<#{self.class} `#{self.inner_desc}`#{all_location_text} via #{source.inspect}>"
       end
 
+      # @return [String]
       def all_location_text
         if location.nil? && type_location.nil?
           ''
@@ -569,6 +625,7 @@ module Solargraph
         end
       end
 
+      # @return [void]
       def reset_generated!
       end
 

data/lib/solargraph/pin/base_variable.rb

@@ -3,8 +3,8 @@
 module Solargraph
   module Pin
     class BaseVariable < Base
-      include Solargraph::Parser::NodeMethods
       # include Solargraph::Source::NodeMethods
+      include Solargraph::Parser::NodeMethods
 
       # @return [Parser::AST::Node, nil]
       attr_reader :assignment
@@ -43,7 +43,6 @@ 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?

data/lib/solargraph/pin/callable.rb

@@ -21,10 +21,13 @@ module Solargraph
         @parameters = parameters
       end
 
+      # @return [String]
       def method_namespace
         closure.namespace
       end
 
+      # @param other [self]
+      # @return [Pin::Block, nil]
       def combine_blocks(other)
         if block.nil?
           other.block
@@ -57,6 +60,8 @@ module Solargraph
         []
       end
 
+      # @param other [self]
+      # @return [Array<Pin::Parameter>]
       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|
@@ -70,6 +75,7 @@ module Solargraph
         end
       end
 
+      # @return [Array<Pin::Parameter>]
       def blockless_parameters
         if parameters.last&.block?
           parameters[0..-2]
@@ -78,6 +84,7 @@ module Solargraph
         end
       end
 
+      # @return [Array]
       def arity
         [generics, blockless_parameters.map(&:arity_decl), block&.arity]
       end
@@ -125,6 +132,7 @@ module Solargraph
         end
       end
 
+      # @return [String]
       def method_name
         raise "closure was nil in #{self.inspect}" if closure.nil?
         @method_name ||= closure.name
@@ -197,6 +205,7 @@ module Solargraph
         true
       end
 
+      # @return [Integer]
       def mandatory_positional_param_count
         parameters.count(&:arg?)
       end

data/lib/solargraph/pin/closure.rb

@@ -8,6 +8,7 @@ module Solargraph
 
       # @param scope [::Symbol] :class or :instance
       # @param generics [::Array<Pin::Parameter>, nil]
+      # @param generic_defaults [Hash{String => ComplexType}]
       def initialize scope: :class, generics: nil, generic_defaults: {},  **splat
         super(**splat)
         @scope = scope
@@ -15,6 +16,7 @@ module Solargraph
         @generic_defaults = generic_defaults
       end
 
+      # @return [Hash{String => ComplexType}]
       def generic_defaults
         @generic_defaults ||= {}
       end

data/lib/solargraph/pin/common.rb

@@ -3,12 +3,16 @@
 module Solargraph
   module Pin
     module Common
+      # @!method source
+      #   @abstract
+      #   @return [Source, nil]
+      # @type @closure [Pin::Closure, nil]
+
       # @return [Location]
       attr_reader :location
 
+      # @sg-ignore Solargraph::Pin::Common#closure return type could not be inferred
       # @return [Pin::Closure, nil]
-      attr_reader :closure
-
       def closure
         Solargraph.assert_or_log(:closure, "Closure not set on #{self.class} #{name.inspect} from #{source.inspect}") unless @closure
         @closure

data/lib/solargraph/pin/constant.rb

@@ -5,6 +5,8 @@ module Solargraph
     class Constant < BaseVariable
       attr_reader :visibility
 
+      # @param visibility [::Symbol] The visibility of the constant (:public, :protected, or :private)
+      # @param splat [Hash] Additional options supported by superclasses
       def initialize visibility: :public, **splat
         super(**splat)
         @visibility = visibility

data/lib/solargraph/pin/delegated_method.rb

@@ -51,6 +51,7 @@ module Solargraph
       %i[typify realize infer probe].each do |method|
         # @param api_map [ApiMap]
         define_method(method) do |api_map|
+          # @sg-ignore Unresolved call to resolve_method
           resolve_method(api_map)
           # @sg-ignore Need to set context correctly in define_method blocks
           @resolved_method ? @resolved_method.send(method, api_map) : super(api_map)

data/lib/solargraph/pin/local_variable.rb

@@ -26,7 +26,10 @@ module Solargraph
           assignment: assert_same(other, :assignment),
           presence_certain: assert_same(other, :presence_certain?),
         }.merge(attrs)
-        new_attrs[:presence] =  assert_same(other, :presence) unless attrs.key?(:presence)
+        # @sg-ignore Wrong argument type for
+        #   Solargraph::Pin::Base#assert_same: other expected
+        #   Solargraph::Pin::Base, received self
+        new_attrs[:presence] = assert_same(other, :presence) unless attrs.key?(:presence)
 
         super(other, new_attrs)
       end