solargraph 0.47.2 → 0.49.0

data/lib/solargraph/rbs_map.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require 'rbs'
+require 'set'
+
+module Solargraph
+  class RbsMap
+    autoload :Conversions, 'solargraph/rbs_map/conversions'
+    autoload :CoreMap,     'solargraph/rbs_map/core_map'
+    autoload :CoreFills,   'solargraph/rbs_map/core_fills'
+    autoload :CoreSigns,   'solargraph/rbs_map/core_signs'
+    autoload :StdlibMap,   'solargraph/rbs_map/stdlib_map'
+
+    include Conversions
+
+    # @type [Hash{String => RbsMap}]
+    @@rbs_maps_hash = {}
+
+    attr_reader :library
+
+    # @param library [String]
+    def initialize library
+      @library = library
+      loader = RBS::EnvironmentLoader.new(core_root: nil, repository: repository)
+      add_library loader, library
+      return unless resolved?
+      environment = RBS::Environment.from_loader(loader).resolve_type_names
+      environment.declarations.each { |decl| convert_decl_to_pin(decl, Solargraph::Pin::ROOT_PIN) }
+    end
+
+    def path_pin path
+      pins.find { |p| p.path == path }
+    end
+
+    def path_pins path
+      pins.select { |p| p.path == path }
+    end
+
+    def resolved?
+      @resolved
+    end
+
+    # @param library [String]
+    # @return [RbsMap]
+    def self.load library
+      @@rbs_maps_hash[library] ||= RbsMap.new(library)
+    end
+
+    def repository
+      @repository ||= RBS::Repository.new(no_stdlib: true)
+    end
+
+    private
+
+    # @param loader [RBS::EnvironmentLoader]
+    # @param library [String]
+    # @return [Boolean] true if adding the library succeeded
+    def add_library loader, library
+      @resolved = if loader.has_library?(library: library, version: nil)
+        loader.add library: library
+        Solargraph.logger.info "#{short_name} successfully loaded library #{library}"
+        true
+      else
+        Solargraph.logger.info "#{short_name} failed to load library #{library}"
+        false
+      end
+    end
+
+    def short_name
+      self.class.name.split('::').last
+    end
+  end
+end

data/lib/solargraph/shell.rb

@@ -71,43 +71,47 @@ module Solargraph
       STDOUT.puts "Configuration file initialized."
     end
 
-    desc 'download-core [VERSION]', 'Download core documentation'
-    def download_core version = nil
-      ver = version || Solargraph::YardMap::CoreDocs.best_download
-      if RUBY_VERSION != ver
-        puts "Documentation for #{RUBY_VERSION} is not available. Reverting to closest match..."
-      end
-      puts "Downloading docs for #{ver}..."
-      Solargraph::YardMap::CoreDocs.download ver
-      # Clear cached documentation if it exists
-      FileUtils.rm_rf Dir.glob(File.join(Solargraph::YardMap::CoreDocs.cache_dir, ver, '*.ser'))
-      puts "Download complete."
-    rescue ArgumentError => e
-      STDERR.puts "ERROR: #{e.message}"
-      STDERR.puts "Run `solargraph available-cores` for a list."
-      exit 1
+    desc 'download-core [VERSION]', 'Download core documentation [deprecated]'
+    long_desc %(
+      The `download-core` command is deprecated. Current versions of Solargraph
+      use RBS for core and stdlib documentation.
+    )
+    # @deprecated
+    def download_core _version = nil
+      puts 'The `download-core` command is deprecated.'
+      puts 'Current versions of Solargraph use RBS for core and stdlib documentation.'
     end
 
-    desc 'list-cores', 'List the local documentation versions'
+    desc 'list-cores', 'List the local documentation versions [deprecated]'
+    long_desc %(
+      The `list-cores` command is deprecated. Current versions of Solargraph use
+      RBS for core and stdlib documentation.
+    )
+    # @deprecated
     def list_cores
-      puts Solargraph::YardMap::CoreDocs.versions.join("\n")
+      puts 'The `list-cores` command is deprecated.'
+      puts 'Current versions of Solargraph use RBS for core and stdlib documentation.'
     end
 
-    desc 'available-cores', 'List available documentation versions'
+    desc 'available-cores', 'List available documentation versions [deprecated]'
+    long_desc %(
+      The `available-cores` command is deprecated. Current versions of Solargraph
+      use RBS for core and stdlib documentation.
+    )
+    # @deprecated
     def available_cores
-      puts Solargraph::YardMap::CoreDocs.available.join("\n")
+      puts 'The `available-cores` command is deprecated.'
+      puts 'Current versions of Solargraph use RBS for core and stdlib documentation.'
     end
 
     desc 'clear', 'Delete all cached documentation'
     long_desc %(
       This command will delete all core and gem documentation from the cache.
-      You can also delete specific gem caches with the `uncache` command or
-      update documentation for specific Ruby versions with the `download-core`
-      command.
     )
+    # @deprecated
     def clear
       puts "Deleting the cached documentation"
-      Solargraph::YardMap::CoreDocs.clear
+      Solargraph::Cache.clear
     end
     map 'clear-cache' => :clear
     map 'clear-cores' => :clear
@@ -191,18 +195,22 @@ module Solargraph
       puts "Scanned #{directory} (#{api_map.pins.length} pins) in #{time.real} seconds."
     end
 
-    desc 'bundle', 'Generate documentation for bundled gems'
+    desc 'bundle', 'Generate documentation for bundled gems [deprecated]'
+    long_desc %(
+      The `bundle` command is deprecated. Solargraph currently uses RBS instead.
+    )
     option :directory, type: :string, aliases: :d, desc: 'The workspace directory', default: '.'
     option :rebuild, type: :boolean, aliases: :r, desc: 'Rebuild existing documentation', default: false
     def bundle
-      Documentor.new(options[:directory], rebuild: options[:rebuild], out: STDOUT).document
+      puts 'The `bundle` command is deprecated. Solargraph currently uses RBS instead.'
     end
 
-    desc 'rdoc GEM [VERSION]', 'Use RDoc to cache documentation'
-    def rdoc gem, version = '>= 0'
-      spec = Gem::Specification.find_by_name(gem, version)
-      puts "Caching #{spec.name} #{spec.version} from RDoc"
-      Solargraph::YardMap::RdocToYard.run(spec)
+    desc 'rdoc GEM [VERSION]', 'Use RDoc to cache documentation [deprecated]'
+    long_desc %(
+      The `rdoc` command is deprecated. Solargraph currently uses RBS instead.
+    )
+    def rdoc _gem, _version = '>= 0'
+      puts 'The `rdoc` command is deprecated. Solargraph currently uses RBS instead.'
     end
 
     private

data/lib/solargraph/source/chain/call.rb

@@ -35,7 +35,10 @@ module Solargraph
             []
           end
           return inferred_pins(found, api_map, name_pin.context, locals) unless found.empty?
-          pins = api_map.get_method_stack(name_pin.binder.namespace, word, scope: name_pin.binder.scope)
+          # @param [ComplexType::UniqueType]
+          pins = name_pin.binder.each_unique_type.flat_map do |context|
+            api_map.get_method_stack(context.namespace, word, scope: context.scope)
+          end
           return [] if pins.empty?
           inferred_pins(pins, api_map, name_pin.context, locals)
         end
@@ -49,36 +52,32 @@ module Solargraph
         # @return [Array<Pin::Base>]
         def inferred_pins pins, api_map, context, locals
           result = pins.map do |p|
-            overloads = p.docstring.tags(:overload)
+            next p unless p.is_a?(Pin::Method)
+            overloads = p.signatures
             # next p if overloads.empty?
             type = ComplexType::UNDEFINED
-            # @param [YARD::Tags::OverloadTag]
             overloads.each do |ol|
-              next unless arguments_match(arguments, ol.parameters)
-              next if ol.parameters.last && ol.parameters.last.first.start_with?('&') && ol.parameters.last.last.nil? && !with_block?
+              next unless arguments_match(arguments, ol)
+              # next if ol.parameters.last && ol.parameters.last.first.start_with?('&') && ol.parameters.last.last.nil? && !with_block?
               match = true
               arguments.each_with_index do |arg, idx|
-                achain = arguments[idx]
-                next if achain.nil?
                 param = ol.parameters[idx]
                 if param.nil?
-                  match = false unless ol.parameters.last && ol.parameters.last.first.start_with?('*')
+                  match = false unless ol.parameters.any?(&:restarg?)
                   break
                 end
-                par = ol.tags(:param).select { |pp| pp.name == param.first }.first
-                next if par.nil? || par.types.nil? || par.types.empty?
-                atype = achain.infer(api_map, Pin::ProxyType.anonymous(context), locals)
-                other = ComplexType.try_parse(*par.types)
+                atype = arg.infer(api_map, Pin::ProxyType.anonymous(context), locals)
                 # @todo Weak type comparison
-                unless atype.tag == other.tag || api_map.super_and_sub?(other.tag, atype.tag)
+                # unless atype.tag == param.return_type.tag || api_map.super_and_sub?(param.return_type.tag, atype.tag)
+                unless param.return_type.undefined? || atype.name == param.return_type.name || api_map.super_and_sub?(param.return_type.name, atype.name)
                   match = false
                   break
                 end
               end
               if match
-                type = extra_return_type(ol, context)
+                type = extra_return_type(p.docstring, context)
                 break if type
-                type = ComplexType.try_parse(*ol.tag(:return).types).self_to(context.to_s).qualify(api_map, context.namespace) if ol.has_tag?(:return) && ol.tag(:return).types && !ol.tag(:return).types.empty? && (type.nil? || type.undefined?)
+                type = with_params(ol.return_type.self_to(context.to_s), context).qualify(api_map, context.namespace) if ol.return_type.defined?
                 type ||= ComplexType::UNDEFINED
               end
               break if type.defined?
@@ -107,9 +106,13 @@ module Solargraph
             p
           end
           result.map do |pin|
-            next pin if pin.return_type.undefined?
-            selfy = pin.return_type.self_to(context.tag)
-            selfy == pin.return_type ? pin : pin.proxy(selfy)
+            if pin.path == 'Class#new' && context.tag != 'Class'
+              pin.proxy(ComplexType.try_parse(context.namespace))
+            else
+              next pin if pin.return_type.undefined?
+              selfy = pin.return_type.self_to(context.tag)
+              selfy == pin.return_type ? pin : pin.proxy(selfy)
+            end
           end
         end
 
@@ -180,14 +183,15 @@ module Solargraph
         end
 
         # @param arguments [Array<Chain>]
-        # @param parameters [Array<String>]
+        # @param signature [Pin::Signature]
         # @return [Boolean]
-        def arguments_match arguments, parameters
+        def arguments_match arguments, signature
+          parameters = signature.parameters
           argcount = arguments.length
-          # argcount -= 1 if !arguments.empty? && arguments.last.links.first.word.start_with?('&')
           parcount = parameters.length
-          parcount -= 1 if !parameters.empty? && parameters.last.first.start_with?('&')
-          return false if argcount < parcount && !(argcount == parcount - 1 && parameters.last.first.start_with?('*'))
+          parcount -= 1 if !parameters.empty? && parameters.last.block?
+          return false if signature.block? && !with_block?
+          return false if argcount < parcount && !(argcount == parcount - 1 && parameters.last.restarg?)
           true
         end
 
@@ -198,6 +202,13 @@ module Solargraph
           pins = api_map.get_method_stack(name_pin.namespace, name_pin.name, scope: name_pin.scope)
           pins.reject{|p| p.path == name_pin.path}
         end
+
+        # @param type [ComplexType]
+        # @param context [ComplexType]
+        def with_params type, context
+          return type unless type.to_s.include?('$')
+          ComplexType.try_parse(type.to_s.gsub('$', context.value_types.map(&:tag).join(', ')).gsub('<>', ''))
+        end
       end
     end
   end

data/lib/solargraph/source/chain.rb

@@ -63,11 +63,11 @@ module Solargraph
         working_pin = name_pin
         links[0..-2].each do |link|
           pins = link.resolve(api_map, working_pin, locals)
-          type = infer_first_defined(pins, working_pin, api_map)
+          type = infer_first_defined(pins, working_pin, api_map, locals)
           return [] if type.undefined?
           working_pin = Pin::ProxyType.anonymous(type)
         end
-        links.last.last_context = working_pin
+        links.last.last_context = name_pin
         links.last.resolve(api_map, working_pin, locals)
       end
 
@@ -76,8 +76,12 @@ module Solargraph
       # @param locals [Array<Pin::Base>]
       # @return [ComplexType]
       def infer api_map, name_pin, locals
+        from_here = base.infer(api_map, name_pin, locals) unless links.length == 1
+        if from_here
+          name_pin = name_pin.proxy(from_here)
+        end
         pins = define(api_map, name_pin, locals)
-        type = infer_first_defined(pins, links.last.last_context, api_map)
+        type = infer_first_defined(pins, links.last.last_context, api_map, locals)
         maybe_nil(type)
       end
 
@@ -110,9 +114,10 @@ module Solargraph
       private
 
       # @param pins [Array<Pin::Base>]
+      # @param context [Pin::Base]
       # @param api_map [ApiMap]
       # @return [ComplexType]
-      def infer_first_defined pins, context, api_map
+      def infer_first_defined pins, context, api_map, locals
         possibles = []
         pins.each do |pin|
           # Avoid infinite recursion
@@ -121,8 +126,18 @@ module Solargraph
           type = pin.typify(api_map)
           @@inference_stack.pop
           if type.defined?
-            possibles.push type
-            break if pin.is_a?(Pin::Method)
+            if type.parameterized?
+              type = type.resolve_parameters(pin.closure, context)
+              # idx = pin.closure.parameters.index(type.subtypes.first.name)
+              # next if idx.nil?
+              # param_type = context.return_type.all_params[idx]
+              # next unless param_type
+              # type = ComplexType.try_parse(param_type.to_s)
+            end
+            if type.defined?
+              possibles.push type
+              break if pin.is_a?(Pin::Method)
+            end
           end
         end
         if possibles.empty?

data/lib/solargraph/source_map/clip.rb

@@ -43,6 +43,11 @@ module Solargraph
       # @return [ComplexType]
       def infer
         result = cursor.chain.infer(api_map, block, locals)
+        if result.tag == 'Class'
+          # HACK: Exception to return Object from Class#new
+          dfn = cursor.chain.define(api_map, block, locals).first
+          return ComplexType.try_parse('Object') 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)
       end

data/lib/solargraph/source_map/mapper.rb

@@ -24,6 +24,8 @@ module Solargraph
         @code = source.code
         @comments = source.comments
         @pins, @locals = Parser.map(source)
+        @pins.each { |p| p.source = :code }
+        @locals.each { |l| l.source = :code }
         process_comment_directives
         [@pins, @locals]
       # rescue Exception => e

data/lib/solargraph/type_checker.rb

@@ -120,12 +120,10 @@ module Solargraph
     # @param pin [Pin::Base]
     # @return [Boolean]
     def resolved_constant? pin
-      api_map.get_constants('', pin.binder.tag)
+      return true if pin.typify(api_map).defined?
+      api_map.get_constants('', *pin.closure.gates)
         .select { |p| p.name == pin.return_type.namespace }
-        .any? do |p|
-          inferred = p.infer(api_map)
-          ['Class', 'Module'].include?(inferred.name)
-        end
+        .any? { |p| p.infer(api_map).defined? }
     end
 
     def virtual_pin? pin
@@ -139,10 +137,12 @@ module Solargraph
       params = first_param_hash(stack)
       result = []
       if rules.require_type_tags?
-        pin.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)
+        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]
+              result.push Problem.new(pin.location, "Missing @param tag for #{par.name} on #{pin.path}", pin: pin)
+            end
           end
         end
       end
@@ -184,7 +184,7 @@ module Solargraph
             elsif declared_externally?(pin)
               ignored_pins.push pin
             end
-          elsif !pin.is_a?(Pin::Parameter)
+          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
@@ -243,7 +243,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 ignored_pins.include?(found)
+            unless closest.parameterized? || ignored_pins.include?(found)
               result.push Problem.new(location, "Unresolved call to #{missing.links.last.word}")
               @marked_ranges.push rng
             end
@@ -273,34 +273,44 @@ module Solargraph
           end
           break unless rules.validate_calls?
           params = first_param_hash(pins)
-          pin.parameters.each_with_index do |par, idx|
-            argchain = base.links.last.arguments[idx]
-            if argchain.nil? && par.decl == :arg
-              result.push Problem.new(location, "Not enough arguments to #{pin.path}")
-              break
-            end
-            if argchain
-              if par.decl != :arg
-                result.concat kwarg_problems_for argchain, api_map, block_pin, locals, location, pin, params, idx
-                break
-              else
-                ptype = params.key?(par.name) ? params[par.name][:qualified] : ComplexType::UNDEFINED
-                if ptype.nil?
-                  # @todo Some level (strong, I guess) should require the param here
+
+          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]
+              if argchain.nil? && par.decl == :arg
+                errors.push Problem.new(location, "Not enough arguments to #{pin.path}")
+                next
+              end
+              if argchain
+                if par.decl != :arg
+                  errors.concat kwarg_problems_for argchain, api_map, block_pin, locals, location, pin, params, idx
+                  next
                 else
-                  argtype = argchain.infer(api_map, block_pin, locals)
-                  if argtype.defined? && ptype.defined? && !any_types_match?(api_map, ptype, argtype)
-                    result.push Problem.new(location, "Wrong argument type for #{pin.path}: #{par.name} expected #{ptype}, received #{argtype}")
+                  ptype = params.key?(par.name) ? params[par.name][:qualified] : ComplexType::UNDEFINED
+                  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
-            elsif par.rest?
-              next
-            elsif par.decl == :kwarg
-              result.push Problem.new(location, "Call to #{pin.path} is missing keyword argument #{par.name}")
+            end
+            if errors.empty?
+              all_errors.clear
               break
             end
+            all_errors.concat errors
           end
+          result.concat all_errors
         end
         base = base.base
       end
@@ -310,7 +320,7 @@ module Solargraph
     def kwarg_problems_for argchain, api_map, block_pin, locals, location, pin, params, first
       result = []
       kwargs = convert_hash(argchain.node)
-      pin.parameters[first..-1].each_with_index do |par, cur|
+      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 == '{}')
@@ -381,8 +391,10 @@ module Solargraph
       pin.location && api_map.bundled?(pin.location.filename)
     end
 
+    # True if the pin is either internal (part of the workspace) or from the core/stdlib
     def internal_or_core? pin
-      internal?(pin) || api_map.yard_map.core_pins.include?(pin) || api_map.yard_map.stdlib_pins.include?(pin)
+      # @todo RBS pins are not necessarily core/stdlib pins
+      internal?(pin) || pin.source == :rbs
     end
 
     # @param pin [Pin::Base]
@@ -417,20 +429,20 @@ module Solargraph
       true
     end
 
-    # @param pin [Pin::Method]
-    def arity_problems_for(pin, arguments, location)
-      ([pin] + pin.overloads).map do |p|
-        result = pin_arity_problems_for(p, arguments, location)
-        return [] if result.empty?
-        result
-      end.flatten.uniq(&:message)
+    def arity_problems_for pin, arguments, location
+      results = pin.signatures.map do |sig|
+        r = parameterized_arity_problems_for(pin, sig.parameters, arguments, location)
+        return [] if r.empty?
+        r
+      end
+      results.first
     end
 
-    # @param pin [Pin::Method]
-    def pin_arity_problems_for(pin, arguments, location)
+    def parameterized_arity_problems_for(pin, parameters, arguments, location)
       return [] unless pin.explicit?
-      return [] if pin.parameters.empty? && arguments.empty?
-      if pin.parameters.empty?
+      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)
@@ -438,21 +450,21 @@ module Solargraph
       end
       unchecked = arguments.clone
       add_params = 0
-      if unchecked.empty? && pin.parameters.any? { |param| param.decl == :kwarg }
+      if unchecked.empty? && parameters.any? { |param| param.decl == :kwarg }
         return [Problem.new(location, "Missing keyword arguments to #{pin.path}")]
       end
       settled_kwargs = 0
       unless unchecked.empty?
         if any_splatted_call?(unchecked.map(&:node))
-          settled_kwargs = pin.parameters.count(&:keyword?)
+          settled_kwargs = parameters.count(&:keyword?)
         else
           kwargs = convert_hash(unchecked.last.node)
-          if pin.parameters.any? { |param| [:kwarg, :kwoptarg].include?(param.decl) || param.kwrestarg? }
+          if parameters.any? { |param| [:kwarg, :kwoptarg].include?(param.decl) || param.kwrestarg? }
             if kwargs.empty?
               add_params += 1
             else
               unchecked.pop
-              pin.parameters.each do |param|
+              parameters.each do |param|
                 next unless param.keyword?
                 if kwargs.key?(param.name.to_sym)
                   kwargs.delete param.name.to_sym
@@ -462,7 +474,7 @@ module Solargraph
                   return [Problem.new(location, "Missing keyword argument #{param.name} to #{pin.path}")]
                 end
               end
-              kwargs.clear if pin.parameters.any?(&:kwrestarg?)
+              kwargs.clear if parameters.any?(&:kwrestarg?)
               unless kwargs.empty?
                 return [Problem.new(location, "Unrecognized keyword argument #{kwargs.keys.first} to #{pin.path}")]
               end
@@ -470,18 +482,18 @@ module Solargraph
           end
         end
       end
-      req = required_param_count(pin)
+      req = required_param_count(parameters)
       if req + add_params < unchecked.length
-        return [] if pin.parameters.any?(&:rest?)
-        opt = optional_param_count(pin)
+        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)) && (pin.parameters.map(&:decl) & [:kwarg, :kwoptarg, :kwrestarg]).any?
+        if req + add_params + 1 == unchecked.length && any_splatted_call?(unchecked.map(&:node)) && (parameters.map(&:decl) & [:kwarg, :kwoptarg, :kwrestarg]).any?
           return []
         end
-        return [] if arguments.length - req == pin.parameters.select { |p| [:optarg, :kwoptarg].include?(p.decl) }.length
+        return [] if arguments.length - req == parameters.select { |p| [:optarg, :kwoptarg].include?(p.decl) }.length
         return [Problem.new(location, "Too many arguments to #{pin.path}")]
       elsif unchecked.length < req - settled_kwargs && (arguments.empty? || (!arguments.last.splat? && !arguments.last.links.last.is_a?(Solargraph::Source::Chain::Hash)))
         # HACK: Kernel#raise signature is incorrect in Ruby 2.7 core docs.
@@ -493,19 +505,13 @@ module Solargraph
       []
     end
 
-    # @param pin [Pin::Method]
-    def required_param_count(pin)
-      pin.parameters.sum { |param| %i[arg kwarg].include?(param.decl) ? 1 : 0 }
+    def required_param_count(parameters)
+      parameters.sum { |param| %i[arg kwarg].include?(param.decl) ? 1 : 0 }
     end
 
     # @param pin [Pin::Method]
-    def optional_param_count(pin)
-      count = 0
-      pin.parameters.each do |param|
-        next unless param.decl == :optarg
-        count += 1
-      end
-      count
+    def optional_param_count(parameters)
+      parameters.select { |p| p.decl == :optarg }.length
     end
 
     def abstract? pin

data/lib/solargraph/version.rb

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

data/lib/solargraph/views/environment.erb

@@ -30,10 +30,10 @@
       Solargraph Version: <%= Solargraph::VERSION %>
     </li>
     <li>
-      Core Documentation Version: <%= Solargraph::YardMap::CoreDocs.best_match %>
+      Core Documentation Version: N/A <%# @todo Fix %>
     </li>
     <li>
-      Core Cache Directory: <%= Solargraph::YardMap::CoreDocs.cache_dir %>
+      Core Cache Directory: N/A <%# @todo Fix %>
     </li>
     <% unless Solargraph::Parser.rubyvm? %>
       <li>