solargraph 0.56.2 → 0.57.0

data/lib/solargraph/pin/constant.rb

@@ -5,6 +5,8 @@ module Solargraph
     class Constant < BaseVariable
       attr_reader :visibility
 
+      # @param visibility [::Symbol] The visibility of the constant (:public, :protected, or :private)
+      # @param splat [Hash] Additional options supported by superclasses
       def initialize visibility: :public, **splat
         super(**splat)
         @visibility = visibility

data/lib/solargraph/pin/delegated_method.rb

@@ -51,6 +51,7 @@ module Solargraph
       %i[typify realize infer probe].each do |method|
         # @param api_map [ApiMap]
         define_method(method) do |api_map|
+          # @sg-ignore Unresolved call to resolve_method
           resolve_method(api_map)
           # @sg-ignore Need to set context correctly in define_method blocks
           @resolved_method ? @resolved_method.send(method, api_map) : super(api_map)

data/lib/solargraph/pin/local_variable.rb

@@ -26,7 +26,10 @@ module Solargraph
           assignment: assert_same(other, :assignment),
           presence_certain: assert_same(other, :presence_certain?),
         }.merge(attrs)
-        new_attrs[:presence] =  assert_same(other, :presence) unless attrs.key?(:presence)
+        # @sg-ignore Wrong argument type for
+        #   Solargraph::Pin::Base#assert_same: other expected
+        #   Solargraph::Pin::Base, received self
+        new_attrs[:presence] = assert_same(other, :presence) unless attrs.key?(:presence)
 
         super(other, new_attrs)
       end

data/lib/solargraph/pin/method.rb

@@ -22,7 +22,8 @@ module Solargraph
       # @param attribute [Boolean]
       # @param signatures [::Array<Signature>, nil]
       # @param anon_splat [Boolean]
-      def initialize visibility: :public, explicit: true, block: :undefined, node: nil, attribute: false, signatures: nil, anon_splat: false, **splat
+      def initialize visibility: :public, explicit: true, block: :undefined, node: nil, attribute: false, signatures: nil, anon_splat: false,
+                     **splat
         super(**splat)
         @visibility = visibility
         @explicit = explicit
@@ -50,7 +51,7 @@ module Solargraph
       end
 
       # @param other [Pin::Method]
-      # @return [Symbol]
+      # @return [::Symbol]
       def combine_visibility(other)
         if dodgy_visibility_source? && !other.dodgy_visibility_source?
           other.visibility
@@ -76,6 +77,9 @@ module Solargraph
       end
 
       def combine_with(other, attrs = {})
+        priority_choice = choose_priority(other)
+        return priority_choice unless priority_choice.nil?
+
         sigs = combine_signatures(other)
         parameters = if sigs.length > 0
           [].freeze
@@ -301,7 +305,6 @@ module Solargraph
         super
       end
 
-      # @sg-ignore
       def documentation
         if @documentation.nil?
           method_docs ||= super || ''
@@ -425,7 +428,7 @@ module Solargraph
         @resolved_ref_tag = true
         return self unless docstring.ref_tags.any?
         docstring.ref_tags.each do |tag|
-          ref = if tag.owner.to_s.start_with?(/[#\.]/)
+          ref = if tag.owner.to_s.start_with?(/[#.]/)
             api_map.get_methods(namespace)
                    .select { |pin| pin.path.end_with?(tag.owner.to_s) }
                    .first
@@ -549,7 +552,7 @@ module Solargraph
       # @param api_map [ApiMap]
       # @return [ComplexType, nil]
       def resolve_reference ref, api_map
-        parts = ref.split(/[\.#]/)
+        parts = ref.split(/[.#]/)
         if parts.first.empty? || parts.one?
           path = "#{namespace}#{ref}"
         else

data/lib/solargraph/pin/method_alias.rb

@@ -13,6 +13,9 @@ module Solargraph
       # @return [String]
       attr_reader :original
 
+      # @param scope [::Symbol]
+      # @param original [String, nil] The name of the original method
+      # @param splat [Hash] Additional options supported by superclasses
       def initialize scope: :instance, original: nil, **splat
         super(**splat)
         @scope = scope

data/lib/solargraph/pin/parameter.rb

@@ -105,15 +105,13 @@ module Solargraph
         end
       end
 
-      # @return [String]
-      def full
+      # @return [String] the full name of the parameter, including any
+      #   declarative symbols such as `*` or `:` indicating type of
+      #   parameter. This is used in method signatures.
+      def full_name
         case decl
-        when :optarg
-          "#{name} = #{asgn_code || '?'}"
-        when :kwarg
+        when :kwarg, :kwoptarg
           "#{name}:"
-        when :kwoptarg
-          "#{name}: #{asgn_code || '?'}"
         when :restarg
           "*#{name}"
         when :kwrestarg
@@ -125,6 +123,18 @@ module Solargraph
         end
       end
 
+      # @return [String]
+      def full
+        full_name + case decl
+                    when :optarg
+                      " = #{asgn_code || '?'}"
+                    when :kwoptarg
+                      " #{asgn_code || '?'}"
+                    else
+                      ''
+                    end
+      end
+
       # @return [ComplexType]
       def return_type
         if @return_type.nil?
@@ -237,7 +247,7 @@ module Solargraph
       def resolve_reference ref, api_map, skip
         return nil if skip.include?(ref)
         skip.push ref
-        parts = ref.split(/[\.#]/)
+        parts = ref.split(/[.#]/)
         if parts.first.empty?
           path = "#{namespace}#{ref}"
         else

data/lib/solargraph/pin/proxy_type.rb

@@ -4,6 +4,7 @@ module Solargraph
   module Pin
     class ProxyType < Base
       # @param return_type [ComplexType]
+      # @param binder [ComplexType, ComplexType::UniqueType, nil]
       def initialize return_type: ComplexType::UNDEFINED, binder: nil, **splat
         super(**splat)
         @return_type = return_type

data/lib/solargraph/pin/reference/override.rb

@@ -14,16 +14,30 @@ module Solargraph
           nil
         end
 
+        # @param location [Location, nil]
+        # @param name [String]
+        # @param tags [::Array<YARD::Tags::Tag>]
+        # @param delete [::Array<Symbol>]
+        # @param splat [Hash]
         def initialize location, name, tags, delete = [], **splat
           super(location: location, name: name, **splat)
           @tags = tags
           @delete = delete
         end
 
+        # @param name [String]
+        # @param tags [::Array<String>]
+        # @param delete [::Array<Symbol>]
+        # @param splat [Hash]
+        # @return [Solargraph::Pin::Reference::Override]
         def self.method_return name, *tags, delete: [], **splat
-          new(nil, name, [YARD::Tags::Tag.new('return', nil, tags)], delete, **splat)
+          new(nil, name, [YARD::Tags::Tag.new('return', '', tags)], delete, **splat)
         end
 
+        # @param name [String]
+        # @param comment [String]
+        # @param splat [Hash]
+        # @return [Solargraph::Pin::Reference::Override]
         def self.from_comment name, comment, **splat
           new(nil, name, Solargraph::Source.parse_docstring(comment).to_docstring.tags, **splat)
         end

data/lib/solargraph/pin/reference/superclass.rb

@@ -3,7 +3,12 @@
 module Solargraph
   module Pin
     class Reference
+      # A Superclass reference pin.
+      #
       class Superclass < Reference
+        def reference_gates
+          @reference_gates ||= closure.gates - [closure.path]
+        end
       end
     end
   end

data/lib/solargraph/pin/reference.rb

@@ -17,6 +17,32 @@ module Solargraph
         super(**splat)
         @generic_values = generic_values
       end
+
+      # @return [String]
+      def parameter_tag
+        @parameter_tag ||= if generic_values&.any?
+                             "<#{generic_values.join(', ')}>"
+                           else
+                             ''
+                           end
+      end
+
+      # @return [ComplexType]
+      def parametrized_tag
+        @parametrized_tag ||= ComplexType.try_parse(
+          name +
+          if generic_values&.length&.> 0
+            "<#{generic_values.join(', ')}>"
+          else
+            ''
+          end
+        )
+      end
+
+      # @return [Array<String>]
+      def reference_gates
+        closure.gates
+      end
     end
   end
 end

data/lib/solargraph/pin/search.rb

@@ -12,6 +12,8 @@ module Solargraph
         # @return [Pin::Base]
         attr_reader :pin
 
+        # @param match [Float] The match score for the pin
+        # @param pin [Pin::Base]
         def initialize match, pin
           @match = match
           @pin = pin
@@ -48,7 +50,7 @@ module Solargraph
       # @param str2 [String]
       # @return [Float]
       def fuzzy_string_match str1, str2
-        return (1.0 + (str2.length.to_f / str1.length.to_f)) if str1.downcase.include?(str2.downcase)
+        return 1.0 + (str2.length.to_f / str1.length.to_f) if str1.downcase.include?(str2.downcase)
         JaroWinkler.similarity(str1, str2, ignore_case: true)
       end
     end

data/lib/solargraph/pin/signature.rb

@@ -39,6 +39,8 @@ module Solargraph
         end
         return ComplexType::UNDEFINED if closure.nil?
         return ComplexType::UNDEFINED unless closure.is_a?(Pin::Method)
+        # @sg-ignore need is_a? support
+        # @type [Array<Pin::Method>]
         method_stack = closure.rest_of_stack api_map
         logger.debug { "Signature#typify(self=#{self}) - method_stack: #{method_stack}" }
         method_stack.each do |pin|

data/lib/solargraph/pin/symbol.rb

@@ -20,6 +20,10 @@ module Solargraph
         ''
       end
 
+      def closure
+        @closure ||= Pin::ROOT_PIN
+      end
+
       def completion_item_kind
         Solargraph::LanguageServer::CompletionItemKinds::KEYWORD
       end
@@ -36,6 +40,7 @@ module Solargraph
         []
       end
 
+      # @return [::Symbol]
       def visibility
         :public
       end

data/lib/solargraph/pin_cache.rb

@@ -1,3 +1,4 @@
+require 'yard-activesupport-concern'
 require 'fileutils'
 require 'rbs'
 
@@ -26,98 +27,156 @@ module Solargraph
         File.join(base_dir, "ruby-#{RUBY_VERSION}", "rbs-#{RBS::VERSION}", "solargraph-#{Solargraph::VERSION}")
       end
 
+      # @param gemspec [Gem::Specification]
+      # @return [String]
       def yardoc_path gemspec
-        File.join(base_dir, "yard-#{YARD::VERSION}", "#{gemspec.name}-#{gemspec.version}.yardoc")
+        File.join(base_dir,
+                  "yard-#{YARD::VERSION}",
+                  "yard-activesupport-concern-#{YARD::ActiveSupport::Concern::VERSION}",
+                  "#{gemspec.name}-#{gemspec.version}.yardoc")
       end
 
+      # @return [String]
       def stdlib_path
         File.join(work_dir, 'stdlib')
       end
 
+      # @param require [String]
+      # @return [String]
       def stdlib_require_path require
         File.join(stdlib_path, "#{require}.ser")
       end
 
+      # @param require [String]
+      # @return [Array<Pin::Base>]
       def deserialize_stdlib_require require
         load(stdlib_require_path(require))
       end
 
+      # @param require [String]
+      # @param pins [Array<Pin::Base>]
+      # @return [void]
       def serialize_stdlib_require require, pins
         save(stdlib_require_path(require), pins)
       end
 
+      # @return [String]
       def core_path
         File.join(work_dir, 'core.ser')
       end
 
+      # @return [Array<Pin::Base>]
       def deserialize_core
         load(core_path)
       end
 
+      # @param pins [Array<Pin::Base>]
+      # @return [void]
       def serialize_core pins
         save(core_path, pins)
       end
 
+      # @param gemspec [Gem::Specification]
+      # @return [String]
       def yard_gem_path gemspec
         File.join(work_dir, 'yard', "#{gemspec.name}-#{gemspec.version}.ser")
       end
 
+      # @param gemspec [Gem::Specification]
+      # @return [Array<Pin::Base>]
       def deserialize_yard_gem(gemspec)
         load(yard_gem_path(gemspec))
       end
 
+      # @param gemspec [Gem::Specification]
+      # @param pins [Array<Pin::Base>]
+      # @return [void]
       def serialize_yard_gem(gemspec, pins)
         save(yard_gem_path(gemspec), pins)
       end
 
+      # @param gemspec [Gem::Specification]
+      # @return [Boolean]
       def has_yard?(gemspec)
         exist?(yard_gem_path(gemspec))
       end
 
+      # @param gemspec [Gem::Specification]
+      # @param hash [String, nil]
+      # @return [String]
       def rbs_collection_path(gemspec, hash)
         File.join(work_dir, 'rbs', "#{gemspec.name}-#{gemspec.version}-#{hash || 0}.ser")
       end
 
+      # @param gemspec [Gem::Specification]
+      # @return [String]
       def rbs_collection_path_prefix(gemspec)
         File.join(work_dir, 'rbs', "#{gemspec.name}-#{gemspec.version}-")
       end
 
+      # @param gemspec [Gem::Specification]
+      # @param hash [String, nil]
+      # @return [Array<Pin::Base>]
       def deserialize_rbs_collection_gem(gemspec, hash)
         load(rbs_collection_path(gemspec, hash))
       end
 
+      # @param gemspec [Gem::Specification]
+      # @param hash [String, nil]
+      # @param pins [Array<Pin::Base>]n
+      # @return [void]
       def serialize_rbs_collection_gem(gemspec, hash, pins)
         save(rbs_collection_path(gemspec, hash), pins)
       end
 
+      # @param gemspec [Gem::Specification]
+      # @param hash [String, nil]
+      # @return [String]
       def combined_path(gemspec, hash)
         File.join(work_dir, 'combined', "#{gemspec.name}-#{gemspec.version}-#{hash || 0}.ser")
       end
 
+      # @param gemspec [Gem::Specification]
+      # @return [String]
       def combined_path_prefix(gemspec)
         File.join(work_dir, 'combined', "#{gemspec.name}-#{gemspec.version}-")
       end
 
+      # @param gemspec [Gem::Specification]
+      # @param hash [String, nil]
+      # @param pins [Array<Pin::Base>]
+      # @return [void]
       def serialize_combined_gem(gemspec, hash, pins)
         save(combined_path(gemspec, hash), pins)
       end
 
+      # @param gemspec [Gem::Specification]
+      # @param hash [String, nil]
+      # @return [Array<Pin::Base>]
       def deserialize_combined_gem gemspec, hash
         load(combined_path(gemspec, hash))
       end
 
+      # @param gemspec [Gem::Specification]
+      # @param hash [String, nil]
+      # @return [Boolean]
       def has_rbs_collection?(gemspec, hash)
         exist?(rbs_collection_path(gemspec, hash))
       end
 
+      # @return [void]
       def uncache_core
         uncache(core_path)
       end
 
+      # @return [void]
       def uncache_stdlib
         uncache(stdlib_path)
       end
 
+      # @param gemspec [Gem::Specification]
+      # @param out [IO, nil]
+      # @return [void]
       def uncache_gem(gemspec, out: nil)
         uncache(yardoc_path(gemspec), out: out)
         uncache_by_prefix(rbs_collection_path_prefix(gemspec), out: out)
@@ -143,11 +202,12 @@ module Solargraph
         nil
       end
 
+      # @param path [String]
       def exist? *path
-        File.file? join(*path)
+        File.file? File.join(*path)
       end
 
-      # @param path [Array<String>]
+      # @param file [String]
       # @param pins [Array<Pin::Base>]
       # @return [void]
       def save file, pins
@@ -158,8 +218,8 @@ module Solargraph
         logger.debug { "Cache#save: Saved #{pins.length} pins to #{file}" }
       end
 
-      # @return [void]
       # @param path_segments [Array<String>]
+      # @return [void]
       def uncache *path_segments, out: nil
         path = File.join(*path_segments)
         if File.exist?(path)

data/lib/solargraph/position.rb

@@ -26,6 +26,7 @@ module Solargraph
       [line, character]
     end
 
+    # @param other [Position]
     def <=>(other)
       return nil unless other.is_a?(Position)
       if line == other.line
@@ -57,6 +58,7 @@ module Solargraph
     # @return [Integer]
     def self.to_offset text, position
       return 0 if text.empty?
+      # @sg-ignore Unresolved call to + on Integer
       text.lines[0...position.line].sum(&:length) + position.character
     end
 

data/lib/solargraph/range.rb

@@ -24,6 +24,7 @@ module Solargraph
       [start, ending]
     end
 
+    # @param other [BasicObject]
     def <=>(other)
       return nil unless other.is_a?(Range)
       if start == other.start

data/lib/solargraph/rbs_map/conversions.rb

@@ -163,9 +163,10 @@ module Solargraph
             generic_defaults[param.name.to_s] = ComplexType.parse(tag).force_rooted
           end
         end
+        class_name = decl.name.relative!.to_s
         class_pin = Solargraph::Pin::Namespace.new(
           type: :class,
-          name: decl.name.relative!.to_s,
+          name: class_name,
           closure: Solargraph::Pin::ROOT_PIN,
           comments: decl.comment&.string,
           type_location: location_decl_to_pin_location(decl.location),
@@ -180,11 +181,12 @@ module Solargraph
         if decl.super_class
           type = build_type(decl.super_class.name, decl.super_class.args)
           generic_values = type.all_params.map(&:to_s)
+          superclass_name = decl.super_class.name.to_s
           pins.push Solargraph::Pin::Reference::Superclass.new(
             type_location: location_decl_to_pin_location(decl.super_class.location),
             closure: class_pin,
             generic_values: generic_values,
-            name: decl.super_class.name.relative!.to_s,
+            name: superclass_name,
             source: :rbs
           )
         end
@@ -345,7 +347,7 @@ module Solargraph
       }
 
       # @param decl [RBS::AST::Members::MethodDefinition, RBS::AST::Members::AttrReader, RBS::AST::Members::AttrAccessor]
-      # @param closure [Pin::Namespace]
+      # @param closure [Pin::Closure]
       # @param context [Context]
       # @param scope [Symbol] :instance or :class
       # @param name [String] The name of the method
@@ -699,13 +701,13 @@ module Solargraph
       # @return [ComplexType::UniqueType]
       def build_type(type_name, type_args = [])
         base = RBS_TO_YARD_TYPE[type_name.relative!.to_s] || type_name.relative!.to_s
-        params = type_args.map { |a| other_type_to_tag(a) }.reject { |t| t == 'undefined' }.map do |t|
+        params = type_args.map { |a| other_type_to_tag(a) }.map do |t|
           ComplexType.try_parse(t).force_rooted
         end
         if base == 'Hash' && params.length == 2
           ComplexType::UniqueType.new(base, [params.first], [params.last], rooted: true, parameters_type: :hash)
         else
-          ComplexType::UniqueType.new(base, [], params, rooted: true, parameters_type: :list)
+          ComplexType::UniqueType.new(base, [], params.reject(&:undefined?), rooted: true, parameters_type: :list)
         end
       end
 

data/lib/solargraph/rbs_map/core_map.rb

@@ -14,6 +14,7 @@ module Solargraph
 
       def initialize; end
 
+      # @return [Enumerable<Pin::Base>]
       def pins
         return @pins if @pins
 
@@ -39,10 +40,12 @@ module Solargraph
 
       private
 
+      # @return [RBS::EnvironmentLoader]
       def loader
         @loader ||= RBS::EnvironmentLoader.new(repository: RBS::Repository.new(no_stdlib: false))
       end
 
+      # @return [Conversions]
       def conversions
         @conversions ||= Conversions.new(loader: loader)
       end

data/lib/solargraph/rbs_map.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'digest'
 require 'pathname'
 require 'rbs'
 
@@ -22,7 +23,8 @@ module Solargraph
     attr_reader :rbs_collection_config_path
 
     # @param library [String]
-    # @param version [String, nil]
+    # @param version [String, nil
+    # @param rbs_collection_config_path [String, Pathname, nil]
     # @param rbs_collection_paths [Array<Pathname, String>]
     def initialize library, version = nil, rbs_collection_config_path: nil, rbs_collection_paths: []
       if rbs_collection_config_path.nil? && !rbs_collection_paths.empty?
@@ -35,16 +37,18 @@ module Solargraph
       add_library loader, library, version
     end
 
+    # @return [RBS::EnvironmentLoader]
     def loader
       @loader ||= RBS::EnvironmentLoader.new(core_root: nil, repository: repository)
     end
 
-    # @return string representing the version of the RBS info fetched
+    # @return [String] representing the version of the RBS info fetched
     #   for the given library.  Must change when the RBS info is
     #   updated upstream for the same library and version.  May change
     #   if the config for where information comes form changes.
     def cache_key
       @hextdigest ||= begin
+        # @type [String, nil]
         data = nil
         if rbs_collection_config_path
           lockfile_path = RBS::Collection::Config.to_lockfile_path(Pathname.new(rbs_collection_config_path))
@@ -68,6 +72,10 @@ module Solargraph
       end
     end
 
+    # @param gemspec [Gem::Specification]
+    # @param rbs_collection_path [String, Pathname, nil]
+    # @param rbs_collection_config_path [String, Pathname, nil]
+    # @return [RbsMap]
     def self.from_gemspec gemspec, rbs_collection_path, rbs_collection_config_path
       rbs_map = RbsMap.new(gemspec.name, gemspec.version,
                            rbs_collection_paths: [rbs_collection_path].compact,
@@ -80,6 +88,7 @@ module Solargraph
                  rbs_collection_config_path: rbs_collection_config_path)
     end
 
+    # @return [Array<Pin::Base>]
     def pins
       @pins ||= resolved? ? conversions.pins : []
     end
@@ -103,6 +112,7 @@ module Solargraph
       @resolved
     end
 
+    # @return [RBS::Repository]
     def repository
       @repository ||= RBS::Repository.new(no_stdlib: false).tap do |repo|
         @rbs_collection_paths.each do |dir|
@@ -120,16 +130,19 @@ module Solargraph
 
     private
 
+    # @return [RBS::EnvironmentLoader]
     def loader
       @loader ||= RBS::EnvironmentLoader.new(core_root: nil, repository: repository)
     end
 
+    # @return [Conversions]
     def conversions
       @conversions ||= Conversions.new(loader: loader)
     end
 
     # @param loader [RBS::EnvironmentLoader]
     # @param library [String]
+    # @param version [String, nil]
     # @return [Boolean] true if adding the library succeeded
     def add_library loader, library, version
       @resolved = if loader.has_library?(library: library, version: version)

data/lib/solargraph/shell.rb

@@ -36,6 +36,7 @@ module Solargraph
         Signal.trap("TERM") do
           Backport.stop
         end
+        # @sg-ignore Wrong argument type for Backport.prepare_tcp_server: adapter expected Backport::Adapter, received Module<Solargraph::LanguageServer::Transport::Adapter>
         Backport.prepare_tcp_server host: options[:host], port: port, adapter: Solargraph::LanguageServer::Transport::Adapter
         STDERR.puts "Solargraph is listening PORT=#{port} PID=#{Process.pid}"
       end
@@ -52,6 +53,7 @@ module Solargraph
         Signal.trap("TERM") do
           Backport.stop
         end
+        # @sg-ignore Wrong argument type for Backport.prepare_stdio_server: adapter expected Backport::Adapter, received Module<Solargraph::LanguageServer::Transport::Adapter>
         Backport.prepare_stdio_server adapter: Solargraph::LanguageServer::Transport::Adapter
         STDERR.puts "Solargraph is listening on stdio PID=#{Process.pid}"
       end
@@ -258,6 +260,7 @@ module Solargraph
     end
 
     # @param gemspec [Gem::Specification]
+    # @param api_map [ApiMap]
     # @return [void]
     def do_cache gemspec, api_map
       # @todo if the rebuild: option is passed as a positional arg,