solargraph 0.56.2 → 0.58.0

data/lib/solargraph/type_checker.rb

@@ -21,14 +21,23 @@ module Solargraph
     # @return [ApiMap]
     attr_reader :api_map
 
-    # @param filename [String]
+    # @param filename [String, nil]
     # @param api_map [ApiMap, nil]
-    # @param level [Symbol]
-    def initialize filename, api_map: nil, level: :normal
+    # @param level [Symbol] Don't complain about anything above this level
+    # @param workspace [Workspace, nil] Workspace to use for loading
+    #   type checker rules modified by user config
+    # @param type_checker_rules [Hash{Symbol => Symbol}] Overrides for
+    #   type checker rules - e.g., :report_undefined => :strong
+    # @param rules [Rules] Type checker rules object
+    def initialize filename,
+                   api_map: nil,
+                   level: :normal,
+                   workspace: filename ? Workspace.new(File.dirname(filename)) : nil,
+                   rules: workspace ? workspace.rules(level) : Rules.new(level, {})
       @filename = filename
       # @todo Smarter directory resolution
       @api_map = api_map || Solargraph::ApiMap.load(File.dirname(filename))
-      @rules = Rules.new(level)
+      @rules = rules
       # @type [Array<Range>]
       @marked_ranges = []
     end
@@ -38,15 +47,20 @@ module Solargraph
       @source_map ||= api_map.source_map(filename)
     end
 
+    # @return [Source]
+    def source
+      @source_map.source
+    end
+
     # @return [Array<Problem>]
     def problems
       @problems ||= begin
-        without_ignored(
-          method_tag_problems
-            .concat variable_type_tag_problems
-            .concat const_problems
-            .concat call_problems
-        )
+         all = method_tag_problems
+                 .concat(variable_type_tag_problems)
+                 .concat(const_problems)
+                 .concat(call_problems)
+         unignored = without_ignored(all)
+         unignored.concat(unneeded_sgignore_problems)
       end
     end
 
@@ -91,7 +105,7 @@ module Solargraph
     def method_return_type_problems_for pin
       return [] if pin.is_a?(Pin::MethodAlias)
       result = []
-      declared = pin.typify(api_map).self_to_type(pin.full_context).qualify(api_map, pin.full_context.tag)
+      declared = pin.typify(api_map).self_to_type(pin.full_context).qualify(api_map, *pin.gates)
       if declared.undefined?
         if pin.return_type.undefined? && rules.require_type_tags?
           if pin.attribute?
@@ -140,40 +154,39 @@ module Solargraph
 
     # @param pin [Pin::Base]
     def virtual_pin? pin
-      pin.location && source_map.source.comment_at?(pin.location.range.ending)
+      pin.location && source.comment_at?(pin.location.range.ending)
     end
 
     # @param pin [Pin::Method]
     # @return [Array<Problem>]
     def method_param_type_problems_for pin
       stack = api_map.get_method_stack(pin.namespace, pin.name, scope: pin.scope)
-      params = first_param_hash(stack)
       result = []
-      if rules.require_type_tags?
-        pin.signatures.each do |sig|
-          sig.parameters.each do |par|
-            break if par.decl == :restarg || par.decl == :kwrestarg || par.decl == :blockarg
-            unless params[par.name]
-              if pin.attribute?
-                inferred = pin.probe(api_map).self_to_type(pin.full_context)
-                if inferred.undefined?
+      pin.signatures.each do |sig|
+        params = param_details_from_stack(sig, stack)
+        if rules.require_type_tags?
+            sig.parameters.each do |par|
+              break if par.decl == :restarg || par.decl == :kwrestarg || par.decl == :blockarg
+              unless params[par.name]
+                if pin.attribute?
+                  inferred = pin.probe(api_map).self_to_type(pin.full_context)
+                  if inferred.undefined?
+                    result.push Problem.new(pin.location, "Missing @param tag for #{par.name} on #{pin.path}", pin: pin)
+                  end
+                else
                   result.push Problem.new(pin.location, "Missing @param tag for #{par.name} on #{pin.path}", pin: pin)
                 end
-              else
-                result.push Problem.new(pin.location, "Missing @param tag for #{par.name} on #{pin.path}", pin: pin)
               end
             end
-          end
         end
-      end
-      # @todo Should be able to probe type of name and data here
-      # @param name [String]
-      # @param data [Hash{Symbol => BasicObject}]
-      params.each_pair do |name, data|
-        # @type [ComplexType]
-        type = data[:qualified]
-        if type.undefined?
-          result.push Problem.new(pin.location, "Unresolved type #{data[:tagged]} for #{name} param on #{pin.path}", pin: pin)
+        # @param name [String]
+        # @param data [Hash{Symbol => BasicObject}]
+        params.each_pair do |name, data|
+          # @type [ComplexType]
+          type = data[:qualified]
+          if type.undefined?
+            result.push Problem.new(pin.location, "Unresolved type #{data[:tagged]} for #{name} param on #{pin.path}", pin: pin)
+          end
         end
       end
       result
@@ -191,7 +204,7 @@ module Solargraph
         if pin.return_type.defined?
           declared = pin.typify(api_map)
           next if declared.duck_type?
-          if declared.defined?
+          if declared.defined? && pin.assignment
             if rules.validate_tags?
               inferred = pin.probe(api_map)
               if inferred.undefined?
@@ -212,7 +225,7 @@ module Solargraph
           elsif !pin.is_a?(Pin::Parameter) && !resolved_constant?(pin)
             result.push Problem.new(pin.location, "Unresolved type #{pin.return_type} for variable #{pin.name}", pin: pin)
           end
-        else
+        elsif pin.assignment
           inferred = pin.probe(api_map)
           if inferred.undefined? && declared_externally?(pin)
             ignored_pins.push pin
@@ -231,13 +244,14 @@ module Solargraph
     def const_problems
       return [] unless rules.validate_consts?
       result = []
-      Solargraph::Parser::NodeMethods.const_nodes_from(source_map.source.node).each do |const|
+      Solargraph::Parser::NodeMethods.const_nodes_from(source.node).each do |const|
         rng = Solargraph::Range.from_node(const)
         chain = Solargraph::Parser.chain(const, filename)
-        block_pin = source_map.locate_block_pin(rng.start.line, rng.start.column)
+        closure_pin = source_map.locate_closure_pin(rng.start.line, rng.start.column)
+        closure_pin.rebind(api_map)
         location = Location.new(filename, rng)
         locals = source_map.locals_at(location)
-        pins = chain.define(api_map, block_pin, locals)
+        pins = chain.define(api_map, closure_pin, locals)
         if pins.empty?
           result.push Problem.new(location, "Unresolved constant #{Solargraph::Parser::NodeMethods.unpack_name(const)}")
           @marked_ranges.push location.range
@@ -249,21 +263,29 @@ module Solargraph
     # @return [Array<Problem>]
     def call_problems
       result = []
-      Solargraph::Parser::NodeMethods.call_nodes_from(source_map.source.node).each do |call|
+      Solargraph::Parser::NodeMethods.call_nodes_from(source.node).each do |call|
         rng = Solargraph::Range.from_node(call)
         next if @marked_ranges.any? { |d| d.contain?(rng.start) }
         chain = Solargraph::Parser.chain(call, filename)
-        block_pin = source_map.locate_block_pin(rng.start.line, rng.start.column)
+        closure_pin = source_map.locate_closure_pin(rng.start.line, rng.start.column)
+        namespace_pin = closure_pin
+        if call.type == :block
+          # blocks in the AST include the method call as well, so the
+          # node returned by #call_nodes_from needs to be backed out
+          # one closure
+          closure_pin = closure_pin.closure
+        end
+        closure_pin.rebind(api_map)
         location = Location.new(filename, rng)
         locals = source_map.locals_at(location)
-        type = chain.infer(api_map, block_pin, locals)
+        type = chain.infer(api_map, closure_pin, locals)
         if type.undefined? && !rules.ignore_all_undefined?
           base = chain
           missing = chain
           found = nil
           closest = ComplexType::UNDEFINED
           until base.links.first.undefined?
-            found = base.define(api_map, block_pin, locals).first
+            found = base.define(api_map, closure_pin, locals).first
             break if found
             missing = base
             base = base.base
@@ -272,145 +294,160 @@ module Solargraph
           # @todo remove the internal_or_core? check at a higher-than-strict level
           if !found || found.is_a?(Pin::BaseVariable) || (closest.defined? && internal_or_core?(found))
             unless closest.generic? || ignored_pins.include?(found)
-              result.push Problem.new(location, "Unresolved call to #{missing.links.last.word}")
+              if closest.defined?
+                result.push Problem.new(location, "Unresolved call to #{missing.links.last.word} on #{closest}")
+              else
+                result.push Problem.new(location, "Unresolved call to #{missing.links.last.word}")
+              end
               @marked_ranges.push rng
             end
           end
         end
-        result.concat argument_problems_for(chain, api_map, block_pin, locals, location)
+        result.concat argument_problems_for(chain, api_map, closure_pin, locals, location)
       end
       result
     end
 
     # @param chain [Solargraph::Source::Chain]
     # @param api_map [Solargraph::ApiMap]
-    # @param block_pin [Solargraph::Pin::Base]
+    # @param closure_pin [Solargraph::Pin::Closure]
     # @param locals [Array<Solargraph::Pin::Base>]
     # @param location [Solargraph::Location]
     # @return [Array<Problem>]
-    def argument_problems_for chain, api_map, block_pin, locals, location
+    def argument_problems_for chain, api_map, closure_pin, locals, location
       result = []
       base = chain
-      until base.links.length == 1 && base.undefined?
-        last_base_link = base.links.last
-        break unless last_base_link.is_a?(Solargraph::Source::Chain::Call)
-
-        arguments = last_base_link.arguments
-
-        pins = base.define(api_map, block_pin, locals)
-
-        first_pin = pins.first
-        if first_pin.is_a?(Pin::DelegatedMethod) && !first_pin.resolvable?(api_map)
-          # Do nothing, as we can't find the actual method implementation
-        elsif first_pin.is_a?(Pin::Method)
-          # @type [Pin::Method]
-          pin = first_pin
-          ap = if base.links.last.is_a?(Solargraph::Source::Chain::ZSuper)
-            arity_problems_for(pin, fake_args_for(block_pin), location)
-          elsif pin.path == 'Class#new'
-            fqns = if base.links.one?
-              block_pin.namespace
+      # @type last_base_link [Solargraph::Source::Chain::Call]
+      last_base_link = base.links.last
+      return [] unless last_base_link.is_a?(Solargraph::Source::Chain::Call)
+
+      arguments = last_base_link.arguments
+
+      pins = base.define(api_map, closure_pin, locals)
+
+      first_pin = pins.first
+      if first_pin.is_a?(Pin::DelegatedMethod) && !first_pin.resolvable?(api_map)
+        # Do nothing, as we can't find the actual method implementation
+      elsif first_pin.is_a?(Pin::Method)
+        # @type [Pin::Method]
+        pin = first_pin
+        ap = if base.links.last.is_a?(Solargraph::Source::Chain::ZSuper)
+               arity_problems_for(pin, fake_args_for(closure_pin), location)
+             elsif pin.path == 'Class#new'
+               fqns = if base.links.one?
+                        closure_pin.namespace
+                      else
+                        base.base.infer(api_map, closure_pin, locals).namespace
+                      end
+               init = api_map.get_method_stack(fqns, 'initialize').first
+               init ? arity_problems_for(init, arguments, location) : []
+             else
+               arity_problems_for(pin, arguments, location)
+             end
+        return ap unless ap.empty?
+        return [] if !rules.validate_calls? || base.links.first.is_a?(Solargraph::Source::Chain::ZSuper)
+
+        all_errors = []
+        pin.signatures.sort { |sig| sig.parameters.length }.each do |sig|
+          params = param_details_from_stack(sig, pins)
+
+          signature_errors = signature_argument_problems_for location, locals, closure_pin, params, arguments, sig, pin
+
+          if signature_errors.empty?
+            # we found a signature that works - meaning errors from
+            # other signatures don't matter.
+            return []
+          end
+          all_errors.concat signature_errors
+        end
+        result.concat all_errors
+      end
+      result
+    end
+
+    # @param location [Location]
+    # @param locals [Array<Pin::LocalVariable>]
+    # @param closure_pin [Pin::Closure]
+    # @param params [Hash{String => Hash{Symbol => String, Solargraph::ComplexType}}]
+    # @param arguments [Array<Source::Chain>]
+    # @param sig [Pin::Signature]
+    # @param pin [Pin::Method]
+    # @param pins [Array<Pin::Method>]
+    #
+    # @return [Array<Problem>]
+    def signature_argument_problems_for location, locals, closure_pin, params, arguments, sig, pin
+      errors = []
+      # @todo add logic mapping up restarg parameters with
+      #   arguments (including restarg arguments).  Use tuples
+      #   when possible, and when not, ensure provably
+      #   incorrect situations are detected.
+      sig.parameters.each_with_index do |par, idx|
+        return errors if par.decl == :restarg  # bail out and assume the rest is valid pending better arg processing
+        argchain = arguments[idx]
+        if argchain.nil?
+          if par.decl == :arg
+            final_arg = arguments.last
+            if final_arg && final_arg.node.type == :splat
+              argchain = final_arg
+              return errors
             else
-              base.base.infer(api_map, block_pin, locals).namespace
+              errors.push Problem.new(location, "Not enough arguments to #{pin.path}")
             end
-            init = api_map.get_method_stack(fqns, 'initialize').first
-            init ? arity_problems_for(init, arguments, location) : []
           else
-            arity_problems_for(pin, arguments, location)
+            final_arg = arguments.last
+            argchain = final_arg if final_arg && [:kwsplat, :hash].include?(final_arg.node.type)
           end
-          unless ap.empty?
-            result.concat ap
-            break
-          end
-          break if !rules.validate_calls? || base.links.first.is_a?(Solargraph::Source::Chain::ZSuper)
-
-          params = first_param_hash(pins)
-
-          all_errors = []
-          pin.signatures.sort { |sig| sig.parameters.length }.each do |sig|
-            errors = []
-            sig.parameters.each_with_index do |par, idx|
-              # @todo add logic mapping up restarg parameters with
-              #   arguments (including restarg arguments).  Use tuples
-              #   when possible, and when not, ensure provably
-              #   incorrect situations are detected.
-              break if par.decl == :restarg  # bail out pending better arg processing
-              argchain = arguments[idx]
-              if argchain.nil?
-                if par.decl == :arg
-                  final_arg = arguments.last
-                  if final_arg && final_arg.node.type == :splat
-                    argchain = final_arg
-                    next # don't try to apply the type of the splat - unlikely to be specific enough
-                  else
-                    errors.push Problem.new(location, "Not enough arguments to #{pin.path}")
-                    next
-                  end
-                else
-                  final_arg = arguments.last
-                  argchain = final_arg if final_arg && [:kwsplat, :hash].include?(final_arg.node.type)
-                end
-              end
-              if argchain
-                if par.decl != :arg
-                  errors.concat kwarg_problems_for sig, argchain, api_map, block_pin, locals, location, pin, params, idx
-                  next
-                else
-                  if argchain.node.type == :splat && argchain == arguments.last
-                    final_arg = argchain
-                  end
-                  if (final_arg && final_arg.node.type == :splat)
-                    # The final argument given has been seen and was a
-                    # splat, which doesn't give us useful types or
-                    # arities against positional parameters, so let's
-                    # continue on in case there are any required
-                    # kwargs we should warn about
-                    next
-                  end
-
-                  if argchain.node.type == :splat && par != sig.parameters.last
-                    # we have been given a splat and there are more
-                    # arguments to come.
-
-                    # @todo Improve this so that we can skip past the
-                    #   rest of the positional parameters here but still
-                    #   process the kwargs
-                    break
-                  end
-                  ptype = params.key?(par.name) ? params[par.name][:qualified] : ComplexType::UNDEFINED
-                  ptype = ptype.self_to_type(par.context)
-                  if ptype.nil?
-                    # @todo Some level (strong, I guess) should require the param here
-                  else
-                    argtype = argchain.infer(api_map, block_pin, locals)
-                    if argtype.defined? && ptype.defined? && !any_types_match?(api_map, ptype, argtype)
-                      errors.push Problem.new(location, "Wrong argument type for #{pin.path}: #{par.name} expected #{ptype}, received #{argtype}")
-                      next
-                    end
-                  end
-                end
-              elsif par.decl == :kwarg
-                errors.push Problem.new(location, "Call to #{pin.path} is missing keyword argument #{par.name}")
-                next
-              end
+        end
+        if argchain
+          if par.decl != :arg
+            errors.concat kwarg_problems_for sig, argchain, api_map, closure_pin, locals, location, pin, params, idx
+            next
+          else
+            if argchain.node.type == :splat && argchain == arguments.last
+              final_arg = argchain
+            end
+            if (final_arg && final_arg.node.type == :splat)
+              # The final argument given has been seen and was a
+              # splat, which doesn't give us useful types or
+              # arities against positional parameters, so let's
+              # continue on in case there are any required
+              # kwargs we should warn about
+              next
+            end
+            if argchain.node.type == :splat && par != sig.parameters.last
+              # we have been given a splat and there are more
+              # arguments to come.
+
+              # @todo Improve this so that we can skip past the
+              #   rest of the positional parameters here but still
+              #   process the kwargs
+              return errors
             end
-            if errors.empty?
-              all_errors.clear
-              break
+            ptype = params.key?(par.name) ? params[par.name][:qualified] : ComplexType::UNDEFINED
+            ptype = ptype.self_to_type(par.context)
+            if ptype.nil?
+            # @todo Some level (strong, I guess) should require the param here
+            else
+              argtype = argchain.infer(api_map, closure_pin, locals)
+              argtype = argtype.self_to_type(closure_pin.context)
+              if argtype.defined? && ptype.defined? && !any_types_match?(api_map, ptype, argtype)
+                errors.push Problem.new(location, "Wrong argument type for #{pin.path}: #{par.name} expected #{ptype}, received #{argtype}")
+                return errors
+              end
             end
-            all_errors.concat errors
           end
-          result.concat all_errors
+        elsif par.decl == :kwarg
+          errors.push Problem.new(location, "Call to #{pin.path} is missing keyword argument #{par.name}")
+          next
         end
-        base = base.base
       end
-      result
+      errors
     end
 
     # @param sig [Pin::Signature]
     # @param argchain [Source::Chain]
     # @param api_map [ApiMap]
-    # @param block_pin [Pin::Block]
+    # @param closure_pin [Pin::Closure]
     # @param locals [Array<Pin::LocalVariable>]
     # @param location [Location]
     # @param pin [Pin::Method]
@@ -418,13 +455,13 @@ module Solargraph
     # @param idx [Integer]
     #
     # @return [Array<Problem>]
-    def kwarg_problems_for sig, argchain, api_map, block_pin, locals, location, pin, params, idx
+    def kwarg_problems_for sig, argchain, api_map, closure_pin, locals, location, pin, params, idx
       result = []
       kwargs = convert_hash(argchain.node)
       par = sig.parameters[idx]
       argchain = kwargs[par.name.to_sym]
       if par.decl == :kwrestarg || (par.decl == :optarg && idx == pin.parameters.length - 1 && par.asgn_code == '{}')
-        result.concat kwrestarg_problems_for(api_map, block_pin, locals, location, pin, params, kwargs)
+        result.concat kwrestarg_problems_for(api_map, closure_pin, locals, location, pin, params, kwargs)
       else
         if argchain
           data = params[par.name]
@@ -432,8 +469,11 @@ module Solargraph
             # @todo Some level (strong, I guess) should require the param here
           else
             ptype = data[:qualified]
+            ptype = ptype.self_to_type(pin.context)
             unless ptype.undefined?
-              argtype = argchain.infer(api_map, block_pin, locals)
+              # @sg-ignore https://github.com/castwide/solargraph/pull/1127
+              argtype = argchain.infer(api_map, closure_pin, locals).self_to_type(closure_pin.context)
+              # @sg-ignore Unresolved call to defined?
               if argtype.defined? && ptype && !any_types_match?(api_map, ptype, argtype)
                 result.push Problem.new(location, "Wrong argument type for #{pin.path}: #{par.name} expected #{ptype}, received #{argtype}")
               end
@@ -447,19 +487,21 @@ module Solargraph
     end
 
     # @param api_map [ApiMap]
-    # @param block_pin [Pin::Block]
+    # @param closure_pin [Pin::Closure]
     # @param locals [Array<Pin::LocalVariable>]
     # @param location [Location]
     # @param pin [Pin::Method]
     # @param params [Hash{String => [nil, Hash]}]
     # @param kwargs [Hash{Symbol => Source::Chain}]
     # @return [Array<Problem>]
-    def kwrestarg_problems_for(api_map, block_pin, locals, location, pin, params, kwargs)
+    def kwrestarg_problems_for(api_map, closure_pin, locals, location, pin, params, kwargs)
       result = []
       kwargs.each_pair do |pname, argchain|
         next unless params.key?(pname.to_s)
         ptype = params[pname.to_s][:qualified]
-        argtype = argchain.infer(api_map, block_pin, locals)
+        ptype = ptype.self_to_type(pin.context)
+        argtype = argchain.infer(api_map, closure_pin, locals)
+        argtype = argtype.self_to_type(closure_pin.context)
         if argtype.defined? && ptype && !any_types_match?(api_map, ptype, argtype)
           result.push Problem.new(location, "Wrong argument type for #{pin.path}: #{pname} expected #{ptype}, received #{argtype}")
         end
@@ -467,9 +509,32 @@ module Solargraph
       result
     end
 
-    # @param pin [Pin::Method]
+    # @param param_details [Hash{String => Hash{Symbol => String, ComplexType}}]
+    # @param pin [Pin::Method, Pin::Signature]
+    # @param relevant_pin [Pin::Method, Pin::Signature] the pin which is under inspection
+    # @return [void]
+    def add_restkwarg_param_tag_details(param_details, pin, relevant_pin)
+      # see if we have additional tags to pay attention to from YARD -
+      # e.g., kwargs in a **restkwargs splat
+      tags = pin.docstring.tags(:param)
+      tags.each do |tag|
+        next if param_details.key? tag.name.to_s
+        next if tag.types.nil?
+        details = {
+          tagged: tag.types.join(', '),
+          qualified: Solargraph::ComplexType.try_parse(*tag.types).qualify(api_map, pin.full_context.namespace)
+        }
+        # don't complain about a param that didn't come from the pin we're looking at anyway
+        if details[:qualified].defined? ||
+           relevant_pin.parameter_names.include?(tag.name.to_s)
+          param_details[tag.name.to_s] = details
+        end
+      end
+    end
+
+    # @param pin [Pin::Signature]
     # @return [Hash{String => Hash{Symbol => String, ComplexType}}]
-    def param_hash(pin)
+    def signature_param_details(pin)
       # @type [Hash{String => Hash{Symbol => String, ComplexType}}]
       result = {}
       pin.parameters.each do |param|
@@ -488,36 +553,50 @@ module Solargraph
         next if tag.types.nil?
         result[tag.name.to_s] = {
           tagged: tag.types.join(', '),
-          qualified: Solargraph::ComplexType.try_parse(*tag.types).qualify(api_map, pin.full_context.namespace)
+          qualified: Solargraph::ComplexType.try_parse(*tag.types).qualify(api_map, *pin.closure.gates)
         }
       end
       result
     end
 
-    # @param pins [Array<Pin::Method>]
+    # The original signature defines the parameters, but other
+    # signatures and method pins can help by adding type information
+    #
+    # @param param_details [Hash{String => Hash{Symbol => String, ComplexType}}]
+    # @param param_names [Array<String>]
+    # @param new_param_details [Hash{String => Hash{Symbol => String, ComplexType}}]
+    #
+    # @return [void]
+    def add_to_param_details(param_details, param_names, new_param_details)
+      new_param_details.each do |param_name, details|
+        next unless param_names.include?(param_name)
+
+        param_details[param_name] ||= {}
+        param_details[param_name][:tagged] ||= details[:tagged]
+        param_details[param_name][:qualified] ||= details[:qualified]
+      end
+    end
+
+    # @param signature [Pin::Signature]
+    # @param method_pin_stack [Array<Pin::Method>]
     # @return [Hash{String => Hash{Symbol => String, ComplexType}}]
-    def first_param_hash(pins)
-      return {} if pins.empty?
-      first_pin_type = pins.first.typify(api_map)
-      first_pin = pins.first.proxy first_pin_type
-      param_names = first_pin.parameter_names
-      results = param_hash(first_pin)
-      pins[1..].each do |pin|
-        # @todo this assignment from parametric use of Hash should not lose its generic
-        # @type [Hash{String => Hash{Symbol => BasicObject}}]
+    def param_details_from_stack(signature, method_pin_stack)
+      signature_type = signature.typify(api_map)
+      signature = signature.proxy signature_type
+      param_details = signature_param_details(signature)
+      param_names = signature.parameter_names
+
+      method_pin_stack.each do |method_pin|
+        add_restkwarg_param_tag_details(param_details, method_pin, signature)
 
         # documentation of types in superclasses should fail back to
         # subclasses if the subclass hasn't documented something
-        superclass_results = param_hash(pin)
-        superclass_results.each do |param_name, details|
-          next unless param_names.include?(param_name)
-
-          results[param_name] ||= {}
-          results[param_name][:tagged] ||= details[:tagged]
-          results[param_name][:qualified] ||= details[:qualified]
+        method_pin.signatures.each do |sig|
+          add_restkwarg_param_tag_details(param_details, sig, signature)
+          add_to_param_details param_details, param_names, signature_param_details(sig)
         end
       end
-      results
+      param_details
     end
 
     # @param pin [Pin::Base]
@@ -540,20 +619,21 @@ module Solargraph
 
     # @param pin [Pin::BaseVariable]
     def declared_externally? pin
-      return true if pin.assignment.nil?
+      raise "No assignment found" if pin.assignment.nil?
+
       chain = Solargraph::Parser.chain(pin.assignment, filename)
       rng = Solargraph::Range.from_node(pin.assignment)
-      block_pin = source_map.locate_block_pin(rng.start.line, rng.start.column)
+      closure_pin = source_map.locate_closure_pin(rng.start.line, rng.start.column)
       location = Location.new(filename, Range.from_node(pin.assignment))
       locals = source_map.locals_at(location)
-      type = chain.infer(api_map, block_pin, locals)
+      type = chain.infer(api_map, closure_pin, locals)
       if type.undefined? && !rules.ignore_all_undefined?
         base = chain
         missing = chain
         found = nil
         closest = ComplexType::UNDEFINED
         until base.links.first.undefined?
-          found = base.define(api_map, block_pin, locals).first
+          found = base.define(api_map, closure_pin, locals).first
           break if found
           missing = base
           base = base.base
@@ -646,7 +726,6 @@ module Solargraph
     # @param parameters [Enumerable<Pin::Parameter>]
     # @todo need to use generic types in method to choose correct
     #   signature and generate Integer as return type
-    # @sg-ignore
     # @return [Integer]
     def required_param_count(parameters)
       parameters.sum { |param| %i[arg kwarg].include?(param.decl) ? 1 : 0 }
@@ -687,12 +766,48 @@ module Solargraph
       args
     end
 
+    # @return [Set<Integer>]
+    def sg_ignore_lines_processed
+      @sg_ignore_lines_processed ||= Set.new
+    end
+
+    # @return [Set<Integer>]
+    def all_sg_ignore_lines
+      source.associated_comments.select do |_line, text|
+        text.include?('@sg-ignore')
+      end.keys.to_set
+    end
+
+    # @return [Array<Integer>]
+    def unprocessed_sg_ignore_lines
+      (all_sg_ignore_lines - sg_ignore_lines_processed).to_a.sort
+    end
+
+    # @return [Array<Problem>]
+    def unneeded_sgignore_problems
+      return [] unless rules.validate_sg_ignores?
+
+      unprocessed_sg_ignore_lines.map do |line|
+        Problem.new(
+          Location.new(filename, Range.from_to(line, 0, line, 0)),
+          'Unneeded @sg-ignore comment'
+        )
+      end
+    end
+
     # @param problems [Array<Problem>]
     # @return [Array<Problem>]
     def without_ignored problems
       problems.reject do |problem|
-        node = source_map.source.node_at(problem.location.range.start.line, problem.location.range.start.column)
-        node && source_map.source.comments_for(node)&.include?('@sg-ignore')
+        node = source.node_at(problem.location.range.start.line, problem.location.range.start.column)
+        ignored = node && source.comments_for(node)&.include?('@sg-ignore')
+        unless !ignored || all_sg_ignore_lines.include?(problem.location.range.start.line)
+          # :nocov:
+          Solargraph.assert_or_log(:sg_ignore) { "@sg-ignore accounting issue - node is #{node}" }
+          # :nocov:
+        end
+        sg_ignore_lines_processed.add problem.location.range.start.line if ignored
+        ignored
       end
     end
   end