solargraph 0.51.2 → 0.54.2

data/lib/solargraph/source_map/mapper.rb

@@ -64,6 +64,10 @@ module Solargraph
         pins.select{|pin| pin.is_a?(Pin::Closure) and pin.location.range.contain?(position)}.last
       end
 
+      # @param source_position [Position]
+      # @param comment_position [Position]
+      # @param comment [String]
+      # @return [void]
       def process_comment source_position, comment_position, comment
         return unless comment.encode('UTF-8', invalid: :replace, replace: '?') =~ DIRECTIVE_REGEXP
         cmnt = remove_inline_comment_hashes(comment)
@@ -79,6 +83,8 @@ module Solargraph
       end
 
       # @param comment [String]
+      # @param tag [String]
+      # @param start [Integer]
       # @return [Integer]
       def find_directive_line_number comment, tag, start
         # Avoid overruning the index
@@ -107,7 +113,8 @@ module Solargraph
           begin
             src = Solargraph::Source.load_string("def #{directive.tag.name};end", @source.filename)
             region = Parser::Region.new(source: src, closure: namespace)
-            gen_pin = Parser.process_node(src.node, region).first.last
+            method_gen_pins = Parser.process_node(src.node, region).first.select { |pin| pin.is_a?(Pin::Method) }
+            gen_pin = method_gen_pins.last
             return if gen_pin.nil?
             # Move the location to the end of the line so it gets recognized
             # as originating from a comment
@@ -137,7 +144,7 @@ module Solargraph
             )
           end
           if t.nil? || t.include?('w')
-            pins.push Solargraph::Pin::Method.new(
+            method_pin = Solargraph::Pin::Method.new(
               location: location,
               closure: namespace,
               name: "#{directive.tag.name}=",
@@ -146,7 +153,8 @@ module Solargraph
               visibility: :public,
               attribute: true
             )
-            pins.last.parameters.push Pin::Parameter.new(name: 'value', decl: :arg, closure: pins.last)
+            pins.push method_pin
+            method_pin.parameters.push Pin::Parameter.new(name: 'value', decl: :arg, closure: pins.last)
             if pins.last.return_type.defined?
               pins.last.docstring.add_tag YARD::Tags::Tag.new(:param, '', pins.last.return_type.to_s.split(', '), 'value')
             end
@@ -203,10 +211,14 @@ module Solargraph
         end
       end
 
+      # @param line1 [Integer]
+      # @param line2 [Integer]
       def no_empty_lines?(line1, line2)
         @code.lines[line1..line2].none? { |line| line.strip.empty? }
       end
 
+      # @param comment [String]
+      # @return [String]
       def remove_inline_comment_hashes comment
         ctxt = ''
         num = nil

data/lib/solargraph/source_map.rb

@@ -1,49 +1,54 @@
 # frozen_string_literal: true
 
 require 'yard'
-require 'yard-solargraph'
-require 'set'
+require 'solargraph/yard_tags'
 
 module Solargraph
-  # An index of pins and other ApiMap-related data for a Source.
+  # An index of Pins and other ApiMap-related data for a single Source
+  # that can be queried.
   #
   class SourceMap
     autoload :Mapper,        'solargraph/source_map/mapper'
     autoload :Clip,          'solargraph/source_map/clip'
     autoload :Completion,    'solargraph/source_map/completion'
+    autoload :Data,          'solargraph/source_map/data'
 
     # @return [Source]
     attr_reader :source
 
     # @return [Array<Pin::Base>]
-    attr_reader :pins
+    def pins
+      data.pins
+    end
 
-    # @return [Array<Pin::Base>]
-    attr_reader :locals
+    # @return [Array<Pin::LocalVariable>]
+    def locals
+      data.locals
+    end
 
     # @param source [Source]
-    # @param pins [Array<Pin::Base>]
-    # @param locals [Array<Pin::Base>]
-    def initialize source, pins, locals
-      # HACK: Keep the library from changing this
-      @source = source.dup
-      @pins = pins
-      @locals = locals
+    def initialize source
+      @source = source
+
       environ.merge Convention.for_local(self) unless filename.nil?
       self.convention_pins = environ.pins
-      @pin_class_hash = pins.to_set.classify(&:class).transform_values(&:to_a)
       @pin_select_cache = {}
     end
 
+    # @param klass [Class]
+    # @return [Array<Pin::Base>]
     def pins_by_class klass
-      @pin_select_cache[klass] ||= @pin_class_hash.select { |key, _| key <= klass }.values.flatten
+      @pin_select_cache[klass] ||= pin_class_hash.select { |key, _| key <= klass }.values.flatten
     end
 
-    def rebindable_method_names
-      @rebindable_method_names ||= pins_by_class(Pin::Method)
-        .select { |pin| pin.comments && pin.comments.include?('@yieldself') }
-        .map(&:name)
-        .to_set
+    # A hash representing the state of the source map's API.
+    #
+    # ApiMap#catalog uses this value to determine whether it needs to clear its
+    # cache.
+    #
+    # @return [Integer]
+    def api_hash
+      @api_hash ||= (pins_by_class(Pin::Constant) + pins_by_class(Pin::Namespace).select { |pin| pin.namespace.to_s > '' } + pins_by_class(Pin::Reference) + pins_by_class(Pin::Method).map(&:node) + locals).hash
     end
 
     # @return [String]
@@ -99,18 +104,27 @@ module Solargraph
       (pins + locals).select { |pin| pin.location == location }
     end
 
+    # @param line [Integer]
+    # @param character [Integer]
+    # @return [Pin::Method,Pin::Namespace]
     def locate_named_path_pin line, character
       _locate_pin line, character, Pin::Namespace, Pin::Method
     end
 
+    # @param line [Integer]
+    # @param character [Integer]
+    # @return [Pin::Namespace,Pin::Method,Pin::Block]
     def locate_block_pin line, character
       _locate_pin line, character, Pin::Namespace, Pin::Method, Pin::Block
     end
 
+    # @todo Candidate for deprecation
+    #
     # @param other_map [SourceMap]
     # @return [Boolean]
     def try_merge! other_map
       return false if pins.length != other_map.pins.length || locals.length != other_map.locals.length || requires.map(&:name).uniq.sort != other_map.requires.map(&:name).uniq.sort
+
       pins.each_index do |i|
         return false unless pins[i].try_merge!(other_map.pins[i])
       end
@@ -151,23 +165,33 @@ module Solargraph
         SourceMap.map(source)
       end
 
+      # @deprecated
       # @param source [Source]
       # @return [SourceMap]
       def map source
-        result = SourceMap::Mapper.map(source)
-        new(source, *result)
+        new(source)
       end
     end
 
     private
 
+    def pin_class_hash
+      @pin_class_hash ||= pins.to_set.classify(&:class).transform_values(&:to_a)
+    end
+
+    def data
+      @data ||= Data.new(source)
+    end
+
     # @return [Array<Pin::Base>]
     def convention_pins
       @convention_pins || []
     end
 
+    # @param pins [Array<Pin::Base>]
+    # @return [Array<Pin::Base>]
     def convention_pins=(pins)
-      # unmemoizing the document_symbols in case it was called from any of convnetions
+      # unmemoizing the document_symbols in case it was called from any of conventions
       @document_symbols = nil
       @convention_pins = pins
     end
@@ -175,7 +199,7 @@ module Solargraph
     # @param line [Integer]
     # @param character [Integer]
     # @param klasses [Array<Class>]
-    # @return [Pin::Base]
+    # @return [Pin::Base, nil]
     def _locate_pin line, character, *klasses
       position = Position.new(line, character)
       found = nil

data/lib/solargraph/type_checker/checks.rb

@@ -51,8 +51,13 @@ module Solargraph
       # @return [Boolean]
       def any_types_match? api_map, expected, inferred
         return duck_types_match?(api_map, expected, inferred) if expected.duck_type?
+        # walk through the union expected type and see if any members
+        # of the union match the inferred type
         expected.each do |exp|
           next if exp.duck_type?
+          # @todo: there should be a level of typechecking where all
+          #   unique types in the inferred must match one of the
+          #   expected unique types
           inferred.each do |inf|
             # return true if exp == inf || api_map.super_and_sub?(fuzz(inf), fuzz(exp))
             return true if exp == inf || either_way?(api_map, inf, exp)
@@ -103,9 +108,12 @@ module Solargraph
       # @param cls2 [ComplexType::UniqueType]
       # @return [Boolean]
       def either_way?(api_map, cls1, cls2)
-        f1 = fuzz(cls1)
-        f2 = fuzz(cls2)
+        # @todo there should be a level of typechecking which uses the
+        #   full tag with parameters to determine compatibility
+        f1 = cls1.name
+        f2 = cls2.name
         api_map.type_include?(f1, f2) || api_map.super_and_sub?(f1, f2) || api_map.super_and_sub?(f2, f1)
+        # api_map.type_include?(f1, f2) || api_map.super_and_sub?(f1, f2) || api_map.super_and_sub?(f2, f1)
       end
     end
   end

data/lib/solargraph/type_checker/rules.rb

@@ -9,7 +9,8 @@ module Solargraph
         normal: 0,
         typed: 1,
         strict: 2,
-        strong: 3
+        strong: 3,
+        alpha: 4
       }.freeze
 
       # @return [Symbol]
@@ -52,6 +53,10 @@ module Solargraph
       def validate_tags?
         rank > LEVELS[:normal]
       end
+
+      def require_all_return_types_match_inferred?
+        rank >= LEVELS[:alpha]
+      end
     end
   end
 end

data/lib/solargraph/type_checker.rb

@@ -22,7 +22,7 @@ module Solargraph
     attr_reader :api_map
 
     # @param filename [String]
-    # @param api_map [ApiMap]
+    # @param api_map [ApiMap, nil]
     # @param level [Symbol]
     def initialize filename, api_map: nil, level: :normal
       @filename = filename
@@ -51,6 +51,7 @@ module Solargraph
 
     class << self
       # @param filename [String]
+      # @param level [Symbol]
       # @return [self]
       def load filename, level = :normal
         source = Solargraph::Source.load(filename)
@@ -61,6 +62,7 @@ module Solargraph
 
       # @param code [String]
       # @param filename [String, nil]
+      # @param level [Symbol]
       # @return [self]
       def load_string code, filename = nil, level = :normal
         source = Solargraph::Source.load_string(code, filename)
@@ -88,10 +90,15 @@ module Solargraph
     def method_return_type_problems_for pin
       return [] if pin.is_a?(Pin::MethodAlias)
       result = []
-      declared = pin.typify(api_map).self_to(pin.full_context.namespace)
+      declared = pin.typify(api_map).self_to_type(pin.full_context).qualify(api_map, pin.full_context.tag)
       if declared.undefined?
         if pin.return_type.undefined? && rules.require_type_tags?
-          result.push Problem.new(pin.location, "Missing @return tag for #{pin.path}", pin: pin)
+          if pin.attribute?
+            inferred = pin.probe(api_map).self_to_type(pin.full_context)
+            result.push Problem.new(pin.location, "Missing @return tag for #{pin.path}", pin: pin) unless inferred.defined?
+          else
+            result.push Problem.new(pin.location, "Missing @return tag for #{pin.path}", pin: pin)
+          end
         elsif pin.return_type.defined? && !resolved_constant?(pin)
           result.push Problem.new(pin.location, "Unresolved return type #{pin.return_type} for #{pin.path}", pin: pin)
         elsif rules.must_tag_or_infer? && pin.probe(api_map).undefined?
@@ -99,14 +106,14 @@ module Solargraph
         end
       elsif rules.validate_tags?
         unless pin.node.nil? || declared.void? || virtual_pin?(pin) || abstract?(pin)
-          inferred = pin.probe(api_map).self_to(pin.full_context.namespace)
+          inferred = pin.probe(api_map).self_to_type(pin.full_context)
           if inferred.undefined?
             unless rules.ignore_all_undefined? || external?(pin)
               result.push Problem.new(pin.location, "#{pin.path} return type could not be inferred", pin: pin)
             end
           else
-            unless (rules.rank > 1 ? all_types_match?(api_map, inferred, declared) : any_types_match?(api_map, declared, inferred))
-              result.push Problem.new(pin.location, "Declared return type #{declared} does not match inferred type #{inferred} for #{pin.path}", pin: pin)
+            unless (rules.require_all_return_types_match_inferred? ? all_types_match?(api_map, inferred, declared) : any_types_match?(api_map, declared, inferred))
+              result.push Problem.new(pin.location, "Declared return type #{declared.rooted_tags} does not match inferred type #{inferred.rooted_tags} for #{pin.path}", pin: pin)
             end
           end
         end
@@ -121,11 +128,16 @@ module Solargraph
     # @return [Boolean]
     def resolved_constant? pin
       return true if pin.typify(api_map).defined?
-      api_map.get_constants('', *pin.closure.gates)
-        .select { |p| p.name == pin.return_type.namespace }
-        .any? { |p| p.infer(api_map).defined? }
+      constant_pins = api_map.get_constants('', *pin.closure.gates)
+               .select { |p| p.name == pin.return_type.namespace }
+      return true if constant_pins.find { |p| p.typify(api_map).defined? }
+      # will need to probe when a constant name is assigned to a
+      # class/module (alias)
+      return true if constant_pins.find { |p| p.probe(api_map).defined? }
+      false
     end
 
+    # @param pin [Pin::Base]
     def virtual_pin? pin
       pin.location && source_map.source.comment_at?(pin.location.range.ending)
     end
@@ -141,12 +153,23 @@ module Solargraph
           sig.parameters.each do |par|
             break if par.decl == :restarg || par.decl == :kwrestarg || par.decl == :blockarg
             unless params[par.name]
-              result.push Problem.new(pin.location, "Missing @param tag for #{par.name} on #{pin.path}", pin: pin)
+              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
             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)
@@ -155,6 +178,7 @@ module Solargraph
       result
     end
 
+    # @return [Array<Pin::Base>]
     def ignored_pins
       @ignored_pins ||= []
     end
@@ -202,6 +226,7 @@ module Solargraph
       source_map.pins_by_class(Pin::BaseVariable) + source_map.locals.select { |pin| pin.is_a?(Pin::LocalVariable) }
     end
 
+    # @return [Array<Problem>]
     def const_problems
       return [] unless rules.validate_consts?
       result = []
@@ -220,6 +245,7 @@ module Solargraph
       result
     end
 
+    # @return [Array<Problem>]
     def call_problems
       result = []
       Solargraph::Parser::NodeMethods.call_nodes_from(source_map.source.node).each do |call|
@@ -242,8 +268,9 @@ module Solargraph
             base = base.base
           end
           closest = found.typify(api_map) if found
+          # @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.parameterized? || ignored_pins.include?(found)
+            unless closest.generic? || ignored_pins.include?(found)
               result.push Problem.new(location, "Unresolved call to #{missing.links.last.word}")
               @marked_ranges.push rng
             end
@@ -259,49 +286,98 @@ module Solargraph
     # @param block_pin [Solargraph::Pin::Base]
     # @param locals [Array<Solargraph::Pin::Base>]
     # @param location [Solargraph::Location]
+    # @return [Array<Problem>]
     def argument_problems_for chain, api_map, block_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)
 
-        if pins.first.is_a?(Pin::DelegatedMethod) && !pins.first.resolvable?(api_map)
+        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 pins.first.is_a?(Pin::Method)
+        elsif first_pin.is_a?(Pin::Method)
           # @type [Pin::Method]
-          pin = pins.first
+          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
+            else
+              base.base.infer(api_map, block_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, base.links.last.arguments, location)
+            arity_problems_for(pin, arguments, location)
           end
           unless ap.empty?
             result.concat ap
             break
           end
-          break unless rules.validate_calls?
+          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|
-              argchain = base.links.last.arguments[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
-                  errors.push Problem.new(location, "Not enough arguments to #{pin.path}")
-                  next
+                  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
-                  last = base.links.last.arguments.last
-                  argchain = last if last && [:kwsplat, :hash].include?(last.node.type)
+                  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 argchain, api_map, block_pin, locals, location, pin, params, idx
+                  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
@@ -330,10 +406,21 @@ module Solargraph
       result
     end
 
-    def kwarg_problems_for argchain, api_map, block_pin, locals, location, pin, params, idx
+    # @param sig [Pin::Signature]
+    # @param argchain [Source::Chain]
+    # @param api_map [ApiMap]
+    # @param block_pin [Pin::Block]
+    # @param locals [Array<Pin::LocalVariable>]
+    # @param location [Location]
+    # @param pin [Pin::Method]
+    # @param params [Hash{String => [nil, Hash]}]
+    # @param idx [Integer]
+    #
+    # @return [Array<Problem>]
+    def kwarg_problems_for sig, argchain, api_map, block_pin, locals, location, pin, params, idx
       result = []
       kwargs = convert_hash(argchain.node)
-      par = pin.signatures.first.parameters[idx]
+      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)
@@ -358,6 +445,14 @@ module Solargraph
       result
     end
 
+    # @param api_map [ApiMap]
+    # @param block_pin [Pin::Block]
+    # @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)
       result = []
       kwargs.each_pair do |pname, argchain|
@@ -371,8 +466,8 @@ module Solargraph
       result
     end
 
-    # @param [Pin::Method]
-    # @return [Hash]
+    # @param pin [Pin::Method]
+    # @return [Hash{String => Hash{Symbol => BaseObject}}]
     def param_hash(pin)
       tags = pin.docstring.tags(:param)
       return {} if tags.empty?
@@ -387,10 +482,12 @@ module Solargraph
       result
     end
 
-    # @param [Array<Pin::Method>]
-    # @return [Hash]
+    # @param pins [Array<Pin::Method>]
+    # @return [Hash{String => Hash{Symbol => BasicObject}}]
     def first_param_hash(pins)
       pins.each do |pin|
+        # @todo this assignment from parametric use of Hash should not lose its generic
+        # @type [Hash{String => Hash{Symbol => BasicObject}}]
         result = param_hash(pin)
         return result unless result.empty?
       end
@@ -404,6 +501,7 @@ module Solargraph
     end
 
     # True if the pin is either internal (part of the workspace) or from the core/stdlib
+    # @param pin [Pin::Base]
     def internal_or_core? pin
       # @todo RBS pins are not necessarily core/stdlib pins
       internal?(pin) || pin.source == :rbs
@@ -414,6 +512,7 @@ module Solargraph
       !internal? pin
     end
 
+    # @param pin [Pin::Base]
     def declared_externally? pin
       return true if pin.assignment.nil?
       chain = Solargraph::Parser.chain(pin.assignment, filename)
@@ -441,6 +540,10 @@ module Solargraph
       true
     end
 
+    # @param pin [Pin::Method]
+    # @param arguments [Array<Source::Chain>]
+    # @param location [Location]
+    # @return [Array<Problem>]
     def arity_problems_for pin, arguments, location
       results = pin.signatures.map do |sig|
         r = parameterized_arity_problems_for(pin, sig.parameters, arguments, location)
@@ -450,16 +553,15 @@ module Solargraph
       results.first
     end
 
+    # @param pin [Pin::Method]
+    # @param parameters [Array<Pin::Parameter>]
+    # @param arguments [Array<Source::Chain>]
+    # @param location [Location]
+    # @return [Array<Problem>]
     def parameterized_arity_problems_for(pin, parameters, arguments, location)
       return [] unless pin.explicit?
       return [] if parameters.empty? && arguments.empty?
       return [] if pin.anon_splat?
-      if parameters.empty?
-        # Functions tagged param_tuple accepts two arguments (e.g., Hash#[]=)
-        return [] if pin.docstring.tag(:param_tuple) && arguments.length == 2
-        return [] if arguments.length == 1 && arguments.last.links.last.is_a?(Source::Chain::BlockVariable)
-        return [Problem.new(location, "Too many arguments to #{pin.path}")]
-      end
       unchecked = arguments.clone
       add_params = 0
       if unchecked.empty? && parameters.any? { |param| param.decl == :kwarg }
@@ -499,9 +601,6 @@ module Solargraph
         return [] if parameters.any?(&:rest?)
         opt = optional_param_count(parameters)
         return [] if unchecked.length <= req + opt
-        if unchecked.length == req + opt + 1 && unchecked.last.links.last.is_a?(Source::Chain::BlockVariable)
-          return []
-        end
         if req + add_params + 1 == unchecked.length && any_splatted_call?(unchecked.map(&:node)) && (parameters.map(&:decl) & [:kwarg, :kwoptarg, :kwrestarg]).any?
           return []
         end
@@ -517,20 +616,30 @@ module Solargraph
       []
     end
 
+    # @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 }
     end
 
+    # @param parameters [Enumerable<Pin::Parameter>]
     # @param pin [Pin::Method]
+    # @return [Integer]
     def optional_param_count(parameters)
       parameters.select { |p| p.decl == :optarg }.length
     end
 
+    # @param pin [Pin::Method]
     def abstract? pin
-      pin.docstring.has_tag?(:abstract) ||
-        (pin.closure && pin.closure.docstring.has_tag?(:abstract))
+      pin.docstring.has_tag?('abstract') ||
+        (pin.closure && pin.closure.docstring.has_tag?('abstract'))
     end
 
+    # @param pin [Pin::Base]
+    # @return [Array<Source::Chain>]
     def fake_args_for(pin)
       args = []
       with_opts = false
@@ -551,6 +660,8 @@ module Solargraph
       args
     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)

data/lib/solargraph/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Solargraph
-  VERSION = '0.51.2'
+  VERSION = '0.54.2'
 end