solargraph 0.52.0 → 0.53.4

data/lib/solargraph/source_map/clip.rb

@@ -11,9 +11,10 @@ module Solargraph
       def initialize api_map, cursor
         @api_map = api_map
         @cursor = cursor
+        block.rebind(api_map) if block.is_a?(Pin::Block)
       end
 
-      # @return [Array<Pin::Base>]
+      # @return [Array<Pin::Base>] Relevant pins for infering the type of the Cursor's position
       def define
         return [] if cursor.comment? || cursor.chain.literal?
         result = cursor.chain.define(api_map, block, locals)
@@ -50,23 +51,24 @@ module Solargraph
       def infer
         result = cursor.chain.infer(api_map, block, locals)
         if result.tag == 'Class'
-          # HACK: Exception to return Object from Class#new
+          # HACK: Exception to return BasicObject from Class#new
           dfn = cursor.chain.define(api_map, block, locals).first
-          return ComplexType.try_parse('Object') if dfn && dfn.path == 'Class#new'
+          return ComplexType.try_parse('BasicObject') if dfn && dfn.path == 'Class#new'
         end
         return result unless result.tag == 'self'
-        ComplexType.try_parse(cursor.chain.base.infer(api_map, block, locals).namespace)
+        ComplexType.try_parse(cursor.chain.base.infer(api_map, block, locals).tag)
       end
 
       # Get an array of all the locals that are visible from the cursors's
       # position. Locals can be local variables, method parameters, or block
       # parameters. The array starts with the nearest local pin.
       #
-      # @return [Array<Solargraph::Pin::Base>]
+      # @return [::Array<Solargraph::Pin::Base>]
       def locals
         @locals ||= source_map.locals_at(location)
       end
 
+      # @return [::Array<String>]
       def gates
         block.gates
       end
@@ -99,11 +101,12 @@ module Solargraph
         @source_map ||= api_map.source_map(cursor.filename)
       end
 
+      # @return [Location]
       def location
         Location.new(source_map.filename, Solargraph::Range.new(cursor.position, cursor.position))
       end
 
-      # @return [Solargraph::Pin::Base]
+      # @return [Solargraph::Pin::Closure]
       def block
         @block ||= source_map.locate_block_pin(cursor.node_position.line, cursor.node_position.character)
       end
@@ -115,7 +118,7 @@ module Solargraph
         @context_pin ||= source_map.locate_named_path_pin(cursor.node_position.line, cursor.node_position.character)
       end
 
-      # @return [Array<Pin::KeywordParam]
+      # @return [Array<Pin::KeywordParam>]
       def complete_keyword_parameters
         return [] unless cursor.argument? && cursor.chain.links.one? && cursor.word =~ /^[a-z0-9_]*:?$/
         pins = signify
@@ -139,7 +142,7 @@ module Solargraph
         result
       end
 
-      # @param result [Array<Pin::Base>]
+      # @param result [Enumerable<Pin::Base>]
       # @return [Completion]
       def package_completions result
         frag_start = cursor.start_of_word.to_s.downcase
@@ -150,6 +153,7 @@ module Solargraph
         Completion.new(filtered, cursor.range)
       end
 
+      # @return [Completion]
       def tag_complete
         result = []
         match = source_map.code[0..cursor.offset-1].match(/[\[<, ]([a-z0-9_:]*)\z/i)
@@ -168,6 +172,7 @@ module Solargraph
         package_completions(result)
       end
 
+      # @return [Completion]
       def code_complete
         result = []
         result.concat complete_keyword_parameters
@@ -209,13 +214,13 @@ module Solargraph
             result.concat api_map.get_constants(context_pin.context.namespace, *gates)
             result.concat api_map.get_methods(block.binder.namespace, scope: block.binder.scope, visibility: [:public, :private, :protected])
             result.concat api_map.get_methods('Kernel')
-            # result.concat ApiMap.keywords
             result.concat api_map.keyword_pins.to_a
           end
         end
         package_completions(result)
       end
 
+      # @return [Array<Pin::Base>]
       def file_global_methods
         return [] if cursor.word.empty?
         source_map.pins.select do |pin|

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
@@ -204,10 +210,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

@@ -2,7 +2,6 @@
 
 require 'yard'
 require 'solargraph/yard_tags'
-require 'set'
 
 module Solargraph
   # An index of pins and other ApiMap-related data for a Source.
@@ -18,7 +17,7 @@ module Solargraph
     # @return [Array<Pin::Base>]
     attr_reader :pins
 
-    # @return [Array<Pin::Base>]
+    # @return [Array<Pin::LocalVariable>]
     attr_reader :locals
 
     # @param source [Source]
@@ -35,17 +34,12 @@ module Solargraph
       @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
     end
 
-    def rebindable_method_names
-      @rebindable_method_names ||= pins_by_class(Pin::Method)
-        .select { |pin| pin.comments && pin.comments.include?('@yieldreceiver') }
-        .map(&:name)
-        .to_set
-    end
-
     # @return [String]
     def filename
       source.filename
@@ -99,10 +93,16 @@ 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
@@ -166,6 +166,8 @@ module Solargraph
       @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
       @document_symbols = nil
@@ -175,7 +177,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.rb

@@ -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)
@@ -126,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
@@ -158,7 +165,11 @@ module Solargraph
           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)
@@ -167,6 +178,7 @@ module Solargraph
       result
     end
 
+    # @return [Array<Pin::Base>]
     def ignored_pins
       @ignored_pins ||= []
     end
@@ -214,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 = []
@@ -232,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|
@@ -254,6 +268,7 @@ 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.generic? || ignored_pins.include?(found)
               result.push Problem.new(location, "Unresolved call to #{missing.links.last.word}")
@@ -271,6 +286,7 @@ 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
@@ -284,6 +300,14 @@ module Solargraph
           pin = pins.first
           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, base.links.last.arguments, location) : []
           else
             arity_problems_for(pin, base.links.last.arguments, location)
           end
@@ -298,12 +322,21 @@ module Solargraph
           all_errors = []
           pin.signatures.sort { |sig| sig.parameters.length }.each do |sig|
             errors = []
+            # @todo these should be able to be probed
+            # @param par [Parameter]
+            # @param idx [Integer]
             sig.parameters.each_with_index do |par, idx|
               argchain = base.links.last.arguments[idx]
               if argchain.nil?
                 if par.decl == :arg
-                  errors.push Problem.new(location, "Not enough arguments to #{pin.path}")
-                  next
+                  last = base.links.last.arguments.last
+                  if last && last.node.type == :splat
+                    argchain = last
+                    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)
@@ -311,10 +344,15 @@ module Solargraph
               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
+                  last = base.links.last.arguments.last
+                  if last && last.node.type == :splat
+                    next # don't try to apply the type of the splat - unlikely to be specific enough
+                  end
                   ptype = params.key?(par.name) ? params[par.name][:qualified] : ComplexType::UNDEFINED
+                  ptype = ptype.self_to(par.context.namespace)
                   if ptype.nil?
                     # @todo Some level (strong, I guess) should require the param here
                   else
@@ -343,10 +381,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)
@@ -371,6 +420,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|
@@ -384,8 +441,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?
@@ -400,10 +457,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
@@ -417,6 +476,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
@@ -427,6 +487,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)
@@ -454,6 +515,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)
@@ -463,14 +528,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?
-        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 }
@@ -510,9 +576,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
@@ -528,20 +591,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
@@ -562,6 +635,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.52.0'
+  VERSION = '0.53.4'
 end

data/lib/solargraph/workspace/config.rb

@@ -14,7 +14,7 @@ module Solargraph
       # @return [String]
       attr_reader :directory
 
-      # @return [Hash]
+      # @return [Hash{String => BasicObject}]
       attr_reader :raw_data
 
       # @param directory [String]
@@ -41,6 +41,7 @@ module Solargraph
         @excluded ||= process_exclusions(@raw_data['exclude'])
       end
 
+      # @param filename [String]
       def allow? filename
         filename = File.absolute_path(filename, directory)
         filename.start_with?(directory) &&
@@ -111,7 +112,7 @@ module Solargraph
 
       # @return [String]
       def global_config_path
-        ENV['SOLARGRAPH_GLOBAL_CONFIG'] || 
+        ENV['SOLARGRAPH_GLOBAL_CONFIG'] ||
           File.join(Dir.home, '.config', 'solargraph', 'config.yml')
       end
 
@@ -121,7 +122,7 @@ module Solargraph
         File.join(@directory, '.solargraph.yml')
       end
 
-      # @return [Hash]
+      # @return [Hash{String => Array, Hash, Integer}]
       def config_data
         workspace_config = read_config(workspace_config_path)
         global_config = read_config(global_config_path)
@@ -136,15 +137,15 @@ module Solargraph
 
       # Read a .solargraph yaml config
       #
-      # @param directory [String]
-      # @return [Hash, nil]
+      # @param config_path [String]
+      # @return [Hash{String => Array, Hash, Integer}, nil]
       def read_config config_path = ''
         return nil if config_path.empty?
         return nil unless File.file?(config_path)
         YAML.safe_load(File.read(config_path))
       end
 
-      # @return [Hash]
+      # @return [Hash{String => Array, Hash, Integer}]
       def default_config
         {
           'include' => ['**/*.rb'],
@@ -222,6 +223,7 @@ module Solargraph
         glob.gsub(/(\/\*|\/\*\*\/\*\*?)$/, '')
       end
 
+      # @return [Array<String>]
       def excluded_directories
         @raw_data['exclude']
           .select { |g| glob_is_directory?(g) }

data/lib/solargraph/workspace.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require 'open3'
-require 'rubygems'
 require 'json'
 
 module Solargraph
@@ -26,9 +25,11 @@ module Solargraph
 
     # @param directory [String]
     # @param config [Config, nil]
-    def initialize directory = '', config = nil
+    # @param server [Hash]
+    def initialize directory = '', config = nil, server = {}
       @directory = directory
       @config = config
+      @server = server
       load_sources
       @gemnames = []
       @require_paths = generate_require_paths
@@ -135,8 +136,19 @@ module Solargraph
       source_hash[updater.filename] = source_hash[updater.filename].synchronize(updater)
     end
 
+    # @return [String]
+    def command_path
+      server['commandPath'] || 'solargraph'
+    end
+
     private
 
+    # The language server configuration (or an empty hash if the workspace was
+    # not initialized from a server).
+    #
+    # @return [Hash]
+    attr_reader :server
+
     # @return [Hash{String => Solargraph::Source}]
     def source_hash
       @source_hash ||= {}
@@ -200,6 +212,7 @@ module Solargraph
       config.require_paths.map{|p| File.join(directory, p)}
     end
 
+    # @return [void]
     def require_plugins
       config.plugins.each do |plugin|
         begin

data/lib/solargraph/yard_map/cache.rb

@@ -4,13 +4,19 @@ module Solargraph
   class YardMap
     class Cache
       def initialize
+        # @type [Hash{String => Array<Solargraph::Pin::Base>}]
         @path_pins = {}
       end
 
+      # @param path [String]
+      # @param pins [Array<Solargraph::Pin::Base>]
+      # @return [Array<Solargraph::Pin::Base>]
       def set_path_pins path, pins
         @path_pins[path] = pins
       end
 
+      # @param path [String]
+      # @return [Array<Solargraph::Pin::Base>]
       def get_path_pins path
         @path_pins[path]
       end

data/lib/solargraph/yard_map/helpers.rb

@@ -4,7 +4,7 @@ module Solargraph
       module_function
 
       # @param code_object [YARD::CodeObjects::Base]
-      # @param spec [Gem::Specification]
+      # @param spec [Gem::Specification, nil]
       # @return [Solargraph::Location, nil]
       def object_location code_object, spec
         return nil if spec.nil? || code_object.nil? || code_object.file.nil? || code_object.line.nil?