solargraph 0.56.0 → 0.57.0

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
@@ -199,9 +203,11 @@ module Solargraph
             )
           end
           yield_return_type = ComplexType.try_parse(*yieldreturn_tags.flat_map(&:types))
-          block = Signature.new(generics: generics, parameters: yield_parameters, return_type: yield_return_type, source: source, closure: self)
+          block = Signature.new(generics: generics, parameters: yield_parameters, return_type: yield_return_type, source: source,
+                                closure: self, location: location, type_location: type_location)
         end
-        signature = Signature.new(generics: generics, parameters: parameters, return_type: return_type, block: block, closure: self, source: source)
+        signature = Signature.new(generics: generics, parameters: parameters, return_type: return_type, block: block, closure: self, source: source,
+                                  location: location, type_location: type_location)
         block.closure = signature if block
         signature
       end
@@ -299,7 +305,6 @@ module Solargraph
         super
       end
 
-      # @sg-ignore
       def documentation
         if @documentation.nil?
           method_docs ||= super || ''
@@ -423,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
@@ -547,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