solargraph 0.50.0 → 0.53.0

data/lib/solargraph/source_map.rb

@@ -1,8 +1,7 @@
 # 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.
@@ -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]
@@ -30,17 +29,21 @@ module Solargraph
       @pins = pins
       @locals = locals
       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
     end
 
+    # @return [Set<String>]
     def rebindable_method_names
       @rebindable_method_names ||= pins_by_class(Pin::Method)
-        .select { |pin| pin.comments && pin.comments.include?('@yieldself') }
+        .select { |pin| pin.comments && pin.comments.include?('@yieldreceiver') }
         .map(&:name)
         .to_set
     end
@@ -65,11 +68,12 @@ module Solargraph
       @environ ||= Environ.new
     end
 
+    # all pins except Solargraph::Pin::Reference::Reference
     # @return [Array<Pin::Base>]
     def document_symbols
-      @document_symbols ||= pins.select { |pin|
+      @document_symbols ||= (pins + convention_pins).select do |pin|
         pin.path && !pin.path.empty?
-      }
+      end
     end
 
     # @param query [String]
@@ -97,10 +101,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
@@ -159,10 +169,23 @@ module Solargraph
 
     private
 
+    # @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
+      @document_symbols = nil
+      @convention_pins = pins
+    end
+
     # @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

@@ -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)
@@ -91,7 +93,12 @@ module Solargraph
       declared = pin.typify(api_map).self_to(pin.full_context.namespace)
       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(pin.full_context.namespace)
+            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?
@@ -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(pin.full_context.namespace)
+                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|
@@ -243,7 +269,7 @@ module Solargraph
           end
           closest = found.typify(api_map) if found
           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
@@ -254,12 +280,21 @@ module Solargraph
       result
     end
 
+    # @param chain [Solargraph::Source::Chain]
+    # @param api_map [Solargraph::ApiMap]
+    # @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?
         pins = base.define(api_map, block_pin, locals)
-        if pins.first.is_a?(Pin::Method)
+
+        if pins.first.is_a?(Pin::DelegatedMethod) && !pins.first.resolvable?(api_map)
+          # Do nothing, as we can't find the actual method implementation
+        elsif pins.first.is_a?(Pin::Method)
           # @type [Pin::Method]
           pin = pins.first
           ap = if base.links.last.is_a?(Solargraph::Source::Chain::ZSuper)
@@ -271,21 +306,30 @@ module Solargraph
             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 = []
+            # @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? && par.decl == :arg
-                errors.push Problem.new(location, "Not enough arguments to #{pin.path}")
-                next
+              if argchain.nil?
+                if par.decl == :arg
+                  errors.push Problem.new(location, "Not enough arguments to #{pin.path}")
+                  next
+                else
+                  last = base.links.last.arguments.last
+                  argchain = last if last && [:kwsplat, :hash].include?(last.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
                   ptype = params.key?(par.name) ? params[par.name][:qualified] : ComplexType::UNDEFINED
@@ -317,35 +361,53 @@ module Solargraph
       result
     end
 
-    def kwarg_problems_for argchain, api_map, block_pin, locals, location, pin, params, first
+    # @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)
-      pin.signatures.first.parameters[first..-1].each_with_index do |par, cur|
-        idx = first + cur
-        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)
-        else
-          if argchain
-            data = params[par.name]
-            if data.nil?
-              # @todo Some level (strong, I guess) should require the param here
-            else
-              ptype = data[:qualified]
-              next if ptype.undefined?
+      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)
+      else
+        if argchain
+          data = params[par.name]
+          if data.nil?
+            # @todo Some level (strong, I guess) should require the param here
+          else
+            ptype = data[:qualified]
+            unless ptype.undefined?
               argtype = argchain.infer(api_map, block_pin, locals)
               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
             end
-          elsif par.decl == :kwarg
-            result.push Problem.new(location, "Call to #{pin.path} is missing keyword argument #{par.name}")
           end
+        elsif par.decl == :kwarg
+          result.push Problem.new(location, "Call to #{pin.path} is missing keyword argument #{par.name}")
         end
       end
       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|
@@ -359,8 +421,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?
@@ -375,10 +437,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
@@ -392,6 +456,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
@@ -402,6 +467,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)
@@ -429,6 +495,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)
@@ -438,16 +508,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 }
@@ -487,9 +556,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
@@ -505,20 +571,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
@@ -539,10 +615,12 @@ 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)
-        source_map.source.comments_for(node)&.include?('@sg-ignore')
+        node && source_map.source.comments_for(node)&.include?('@sg-ignore')
       end
     end
   end

data/lib/solargraph/version.rb

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

data/lib/solargraph/workspace/config.rb

@@ -14,12 +14,12 @@ module Solargraph
       # @return [String]
       attr_reader :directory
 
-      # @return [Hash]
+      # @return [Hash{String => BasicObject}]
       attr_reader :raw_data
 
       # @param directory [String]
       def initialize directory = ''
-        @directory = directory
+        @directory = File.absolute_path(directory)
         @raw_data = config_data
         included
         excluded
@@ -41,8 +41,10 @@ module Solargraph
         @excluded ||= process_exclusions(@raw_data['exclude'])
       end
 
+      # @param filename [String]
       def allow? filename
-        filename.start_with?(directory) && 
+        filename = File.absolute_path(filename, directory)
+        filename.start_with?(directory) &&
           !excluded.include?(filename) &&
           excluded_directories.none? { |d| filename.start_with?(d) }
       end
@@ -110,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
 
@@ -120,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)
@@ -135,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'],
@@ -171,7 +173,7 @@ module Solargraph
       # @return [Array<String>]
       def process_globs globs
         result = globs.flat_map do |glob|
-          Dir[File.join directory, glob]
+          Dir[File.absolute_path(glob, directory)]
             .map{ |f| f.gsub(/\\/, '/') }
             .select { |f| File.file?(f) }
         end
@@ -186,7 +188,7 @@ module Solargraph
       def process_exclusions globs
         remainder = globs.select do |glob|
           if glob_is_directory?(glob)
-            exdir = File.join(directory, glob_to_directory(glob))
+            exdir = File.absolute_path(glob_to_directory(glob), directory)
             included.delete_if { |file| file.start_with?(exdir) }
             false
           else
@@ -221,10 +223,11 @@ module Solargraph
         glob.gsub(/(\/\*|\/\*\*\/\*\*?)$/, '')
       end
 
+      # @return [Array<String>]
       def excluded_directories
         @raw_data['exclude']
           .select { |g| glob_is_directory?(g) }
-          .map { |g| File.join(directory, glob_to_directory(g)) }
+          .map { |g| File.absolute_path(glob_to_directory(g), directory) }
       end
     end
   end

data/lib/solargraph/workspace.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require 'open3'
-require 'rubygems'
 require 'json'
 
 module Solargraph
@@ -104,7 +103,8 @@ module Solargraph
     # @return [Boolean]
     def would_require? path
       require_paths.each do |rp|
-        return true if File.exist?(File.join(rp, "#{path}.rb"))
+        full = File.join rp, path
+        return true if File.exist?(full) or File.exist?(full << ".rb")
       end
       false
     end
@@ -199,6 +199,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?