solargraph 0.56.2 → 0.58.0

data/lib/solargraph/pin/method.rb

@@ -17,12 +17,13 @@ module Solargraph
 
       # @param visibility [::Symbol] :public, :protected, or :private
       # @param explicit [Boolean]
-      # @param block [Pin::Signature, nil, ::Symbol]
+      # @param block [Pin::Signature, nil, :undefined]
       # @param node [Parser::AST::Node, nil]
       # @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
@@ -33,14 +34,18 @@ module Solargraph
         @anon_splat = anon_splat
       end
 
+      # @param signature_pins [Array<Pin::Signature>]
       # @return [Array<Pin::Signature>]
       def combine_all_signature_pins(*signature_pins)
+        # @type [Hash{Array => Array<Pin::Signature>}]
         by_arity = {}
         signature_pins.each do |signature_pin|
           by_arity[signature_pin.arity] ||= []
           by_arity[signature_pin.arity] << signature_pin
         end
         by_arity.transform_values! do |same_arity_pins|
+          # @param memo [Pin::Signature, nil]
+          # @param signature [Pin::Signature]
           same_arity_pins.reduce(nil) do |memo, signature|
             next signature if memo.nil?
             memo.combine_with(signature)
@@ -50,7 +55,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 +81,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
@@ -84,6 +92,7 @@ module Solargraph
         end
         new_attrs = {
           visibility: combine_visibility(other),
+          # @sg-ignore https://github.com/castwide/solargraph/pull/1050
           explicit: explicit? || other.explicit?,
           block: combine_blocks(other),
           node: choose_node(other, :node),
@@ -294,14 +303,13 @@ module Solargraph
         type = see_reference(api_map) || typify_from_super(api_map)
         logger.debug { "Method#typify(self=#{self}) - type=#{type&.rooted_tags.inspect}" }
         unless type.nil?
-          qualified = type.qualify(api_map, namespace)
+          qualified = type.qualify(api_map, *closure.gates)
           logger.debug { "Method#typify(self=#{self}) => #{qualified.rooted_tags.inspect}" }
           return qualified
         end
         super
       end
 
-      # @sg-ignore
       def documentation
         if @documentation.nil?
           method_docs ||= super || ''
@@ -373,11 +381,14 @@ module Solargraph
         @attribute
       end
 
-      # @parm other [Method]
+      # @parm other [self]
       def nearly? other
         super &&
+          # @sg-ignore https://github.com/castwide/solargraph/pull/1050
           parameters == other.parameters &&
+          # @sg-ignore https://github.com/castwide/solargraph/pull/1050
           scope == other.scope &&
+          # @sg-ignore https://github.com/castwide/solargraph/pull/1050
           visibility == other.visibility
       end
 
@@ -389,9 +400,12 @@ module Solargraph
       def overloads
         # Ignore overload tags with nil parameters. If it's not an array, the
         # tag's source is likely malformed.
+
+        # @param tag [YARD::Tags::OverloadTag]
         @overloads ||= docstring.tags(:overload).select(&:parameters).map do |tag|
           Pin::Signature.new(
             generics: generics,
+            # @param src [Array(String, String)]
             parameters: tag.parameters.map do |src|
               name, decl = parse_overload_param(src.first)
               Pin::Parameter.new(
@@ -425,7 +439,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
@@ -504,6 +518,7 @@ module Solargraph
       #
       # @return [ComplexType]
       def param_type_from_name(tag, name)
+        # @param t [YARD::Tags::Tag]
         param = tag.tags(:param).select { |t| t.name == name }.first
         return ComplexType::UNDEFINED unless param
         ComplexType.try_parse(*param.types)
@@ -519,8 +534,12 @@ module Solargraph
       # @param api_map [ApiMap]
       # @return [ComplexType, nil]
       def see_reference api_map
+        # This should actually be an intersection type
+        # @param ref [YARD::Tags::Tag, Solargraph::Yard::Tags::RefTag]
         docstring.ref_tags.each do |ref|
+          # @sg-ignore ref should actually be an intersection type
           next unless ref.tag_name == 'return' && ref.owner
+          # @sg-ignore ref should actually be an intersection type
           result = resolve_reference(ref.owner.to_s, api_map)
           return result unless result.nil?
         end
@@ -549,11 +568,11 @@ 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
-          fqns = api_map.qualify(parts.first, namespace)
+          fqns = api_map.qualify(parts.first, *gates)
           return ComplexType::UNDEFINED if fqns.nil?
           path = fqns + ref[parts.first.length] + parts.last
         end

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?
@@ -156,7 +166,7 @@ module Solargraph
 
       # @param api_map [ApiMap]
       def typify api_map
-        return return_type.qualify(api_map, closure.context.namespace) unless return_type.undefined?
+        return return_type.qualify(api_map, *closure.gates) unless return_type.undefined?
         closure.is_a?(Pin::Block) ? typify_block_param(api_map) : typify_method_param(api_map)
       end
 
@@ -212,7 +222,7 @@ module Solargraph
           if found.nil? and !index.nil?
             found = params[index] if params[index] && (params[index].name.nil? || params[index].name.empty?)
           end
-          return ComplexType.try_parse(*found.types).qualify(api_map, meth.context.namespace) unless found.nil? || found.types.nil?
+          return ComplexType.try_parse(*found.types).qualify(api_map, *meth.closure.gates) unless found.nil? || found.types.nil?
         end
         ComplexType::UNDEFINED
       end
@@ -222,8 +232,12 @@ module Solargraph
       # @param skip [::Array]
       # @return [::Array<YARD::Tags::Tag>]
       def see_reference heredoc, api_map, skip = []
+        # This should actually be an intersection type
+        # @param ref [YARD::Tags::Tag, Solargraph::Yard::Tags::RefTag]
         heredoc.ref_tags.each do |ref|
+          # @sg-ignore ref should actually be an intersection type
           next unless ref.tag_name == 'param' && ref.owner
+          # @sg-ignore ref should actually be an intersection type
           result = resolve_reference(ref.owner.to_s, api_map, skip)
           return result unless result.nil?
         end
@@ -237,7 +251,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,8 +4,12 @@ module Solargraph
   module Pin
     class ProxyType < Base
       # @param return_type [ComplexType]
-      def initialize return_type: ComplexType::UNDEFINED, binder: nil, **splat
+      # @param gates [Array<String>, nil] Namespaces to try while resolving non-rooted types
+      # @param binder [ComplexType, ComplexType::UniqueType, nil]
+      # @param gates [Array<String>, nil]
+      def initialize return_type: ComplexType::UNDEFINED, binder: nil, gates: nil, **splat
         super(**splat)
+        @gates = gates
         @return_type = return_type
         @binder = binder if binder
       end

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,23 @@ module Solargraph
         super(**splat)
         @generic_values = generic_values
       end
+
+      # @return [ComplexType]
+      def type
+        @type ||= 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
@@ -40,6 +42,9 @@ module Solargraph
           Result.new(match, pin) if match > 0.7
         end
           .compact
+          # @param a [self]
+          # @param b [self]
+          # @sg-ignore https://github.com/castwide/solargraph/pull/1050
           .sort { |a, b| b.match <=> a.match }
           .map(&:pin)
       end
@@ -48,7 +53,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>, nil]
       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>, nil]
       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>, nil]
       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>, nil]
       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>, nil]
       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
 
@@ -110,6 +112,7 @@ module Solargraph
 
     def == other
       return false unless other.is_a?(Position)
+      # @sg-ignore https://github.com/castwide/solargraph/pull/1114
       line == other.line and character == other.character
     end
   end

data/lib/solargraph/range.rb

@@ -24,11 +24,15 @@ module Solargraph
       [start, ending]
     end
 
+    # @param other [BasicObject]
     def <=>(other)
       return nil unless other.is_a?(Range)
+      # @sg-ignore https://github.com/castwide/solargraph/pull/1114
       if start == other.start
+        # @sg-ignore https://github.com/castwide/solargraph/pull/1114
         ending <=> other.ending
       else
+        # @sg-ignore https://github.com/castwide/solargraph/pull/1114
         start <=> other.start
       end
     end
@@ -97,6 +101,7 @@ module Solargraph
 
     def == other
       return false unless other.is_a?(Range)
+      # @sg-ignore https://github.com/castwide/solargraph/pull/1114
       start == other.start && ending == other.ending
     end