solargraph 0.51.2 → 0.54.2

data/lib/solargraph/pin/method.rb

@@ -4,12 +4,9 @@ module Solargraph
   module Pin
     # The base class for method and attribute pins.
     #
-    class Method < Closure
+    class Method < Callable
       include Solargraph::Parser::NodeMethods
 
-      # @return [Array<Pin::Parameter>]
-      attr_reader :parameters
-
       # @return [::Symbol] :public, :private, or :protected
       attr_reader :visibility
 
@@ -18,23 +15,64 @@ module Solargraph
 
       # @param visibility [::Symbol] :public, :protected, or :private
       # @param explicit [Boolean]
-      # @param parameters [Array<Pin::Parameter>]
-      # @param node [Parser::AST::Node, RubyVM::AbstractSyntaxTree::Node]
+      # @param block [Pin::Signature, nil, ::Symbol]
+      # @param node [Parser::AST::Node, nil]
       # @param attribute [Boolean]
-      def initialize visibility: :public, explicit: true, parameters: [], node: nil, attribute: false, signatures: nil, anon_splat: false, **splat
+      # @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
         super(**splat)
         @visibility = visibility
         @explicit = explicit
-        @parameters = parameters
+        @block = block
         @node = node
         @attribute = attribute
         @signatures = signatures
         @anon_splat = anon_splat
       end
 
-      # @return [Array<String>]
-      def parameter_names
-        @parameter_names ||= parameters.map(&:name)
+      def transform_types(&transform)
+        # @todo 'super' alone should work here I think, but doesn't typecheck at level typed
+        m = super(&transform)
+        m.signatures = m.signatures.map do |sig|
+          sig.transform_types(&transform)
+        end
+        m.block = block&.transform_types(&transform)
+        m.signature_help = nil
+        m.documentation = nil
+        m
+      end
+
+      def all_rooted?
+        super && parameters.all?(&:all_rooted?) && (!block || block&.all_rooted?) && signatures.all?(&:all_rooted?)
+      end
+
+      # @param signature [Pin::Signature]
+      # @return [Pin::Method]
+      def with_single_signature(signature)
+        m = proxy signature.return_type
+        m.signature_help = nil
+        m.documentation = nil
+        # @todo populating the single parameters/return_type/block
+        #   arguments here seems to be needed for some specs to pass,
+        #   even though we have a signature with the same information.
+        #   Is this a problem for RBS-populated methods, which don't
+        #   populate these three?
+        m.parameters = signature.parameters
+        m.return_type = signature.return_type
+        m.block = signature.block
+        m.signatures = [signature]
+        m
+      end
+
+      def block?
+        !block.nil?
+      end
+
+      # @return [Pin::Signature, nil]
+      def block
+        return @block unless @block == :undefined
+        @block = signatures.first&.block
       end
 
       def completion_item_kind
@@ -46,22 +84,56 @@ module Solargraph
       end
 
       def return_type
-        @return_type ||= ComplexType.try_parse(*signatures.map(&:return_type).map(&:to_s))
+        @return_type ||= ComplexType.new(signatures.map(&:return_type).flat_map(&:items))
+      end
+
+      # @param parameters [::Array<Parameter>]
+      # @param return_type [ComplexType]
+      # @return [Signature]
+      def generate_signature(parameters, return_type)
+        block = nil
+        yieldparam_tags = docstring.tags(:yieldparam)
+        yieldreturn_tags = docstring.tags(:yieldreturn)
+        generics = docstring.tags(:generic).map(&:name)
+        needs_block_param_signature =
+          parameters.last&.block? || !yieldreturn_tags.empty? || !yieldparam_tags.empty?
+        if needs_block_param_signature
+          yield_parameters = yieldparam_tags.map do |p|
+            name = p.name
+            decl = :arg
+            if name
+              decl = select_decl(name, false)
+              name = clean_param(name)
+            end
+            Pin::Parameter.new(
+              location: location,
+              closure: self,
+              comments: p.text,
+              name: name,
+              decl: decl,
+              presence: location ? location.range : nil,
+              return_type: ComplexType.try_parse(*p.types)
+            )
+          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)
+        end
+        Signature.new(generics: generics, parameters: parameters, return_type: return_type, block: block)
       end
 
-      # @return [Array<Signature>]
+      # @return [::Array<Signature>]
       def signatures
         @signatures ||= begin
           top_type = generate_complex_type
           result = []
-          result.push Signature.new(parameters, top_type) if top_type.defined?
-          result.concat(overloads.map { |meth| Signature.new(meth.parameters, meth.return_type) })
-          result.push Signature.new(parameters, top_type) if result.empty?
+          result.push generate_signature(parameters, top_type) if top_type.defined?
+          result.concat(overloads.map { |meth| generate_signature(meth.parameters, meth.return_type) }) unless overloads.empty?
+          result.push generate_signature(parameters, @return_type || ComplexType::UNDEFINED) if result.empty?
           result
         end
       end
 
-      # @return [String]
+      # @return [String, nil]
       def detail
         # This property is not cached in an instance variable because it can
         # change when pins get proxied.
@@ -77,7 +149,7 @@ module Solargraph
         detail
       end
 
-      # @return [Array<Hash>]
+      # @return [::Array<Hash>]
       def signature_help
         @signature_help ||= signatures.map do |sig|
           {
@@ -87,6 +159,27 @@ module Solargraph
         end
       end
 
+      def desc
+        # ensure the signatures line up when logged
+        if signatures.length > 1
+          "\n#{to_rbs}\n"
+        else
+          to_rbs
+        end
+      end
+
+      def to_rbs
+        return nil if signatures.empty?
+
+        rbs = "def #{name}: #{signatures.first.to_rbs}"
+        signatures[1..].each do |sig|
+          rbs += "\n"
+          rbs += (' ' * (4 + name.length))
+          rbs += "| #{name}: #{sig.to_rbs}"
+        end
+        rbs
+      end
+
       def path
         @path ||= "#{namespace}#{(scope == :instance ? '#' : '.')}#{name}"
       end
@@ -115,6 +208,32 @@ module Solargraph
             end
             @documentation += lines.join("\n")
           end
+          yieldparam_tags = docstring.tags(:yieldparam)
+          unless yieldparam_tags.nil? or yieldparam_tags.empty?
+            @documentation += "\n\n" unless @documentation.empty?
+            @documentation += "Block Params:\n"
+            lines = []
+            yieldparam_tags.each do |p|
+              l = "* #{p.name}"
+              l += " [#{escape_brackets(p.types.join(', '))}]" unless p.types.nil? or p.types.empty?
+              l += " #{p.text}"
+              lines.push l
+            end
+            @documentation += lines.join("\n")
+          end
+          yieldreturn_tags = docstring.tags(:yieldreturn)
+          unless yieldreturn_tags.empty?
+            @documentation += "\n\n" unless @documentation.empty?
+            @documentation += "Block Returns:\n"
+            lines = []
+            yieldreturn_tags.each do |r|
+              l = "*"
+              l += " [#{escape_brackets(r.types.join(', '))}]" unless r.types.nil? or r.types.empty?
+              l += " #{r.text}"
+              lines.push l
+            end
+            @documentation += lines.join("\n")
+          end
           return_tags = docstring.tags(:return)
           unless return_tags.empty?
             @documentation += "\n\n" unless @documentation.empty?
@@ -144,9 +263,9 @@ module Solargraph
       end
 
       def nearly? other
-        return false unless super
-        parameters == other.parameters and
-          scope == other.scope and
+        super &&
+          parameters == other.parameters &&
+          scope == other.scope &&
           visibility == other.visibility
       end
 
@@ -157,14 +276,18 @@ module Solargraph
       def try_merge! pin
         return false unless super
         @node = pin.node
+        @resolved_ref_tag = false
         true
       end
 
-      # @return [Array<Pin::Method>]
+      # @return [::Array<Pin::Method>]
       def overloads
-        @overloads ||= docstring.tags(:overload).map do |tag|
+        # Ignore overload tags with nil parameters. If it's not an array, the
+        # tag's source is likely malformed.
+        @overloads ||= docstring.tags(:overload).select(&:parameters).map do |tag|
           Pin::Signature.new(
-            tag.parameters.map do |src|
+            generics: generics,
+            parameters: tag.parameters.map do |src|
               name, decl = parse_overload_param(src.first)
               Pin::Parameter.new(
                 location: location,
@@ -176,7 +299,7 @@ module Solargraph
                 return_type: param_type_from_name(tag, src.first)
               )
             end,
-            ComplexType.try_parse(*tag.docstring.tags(:return).flat_map(&:types))
+            return_type: ComplexType.try_parse(*tag.docstring.tags(:return).flat_map(&:types))
           )
         end
         @overloads
@@ -186,8 +309,45 @@ module Solargraph
         @anon_splat
       end
 
+      # @param [ApiMap]
+      # @return [self]
+      def resolve_ref_tag api_map
+        return self if @resolved_ref_tag
+
+        @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?(/[#\.]/)
+            api_map.get_methods(namespace)
+                   .select { |pin| pin.path.end_with?(tag.owner.to_s) }
+                   .first
+          else
+            # @todo Resolve relative namespaces
+            api_map.get_path_pins(tag.owner.to_s).first
+          end
+          next unless ref
+
+          docstring.add_tag(*ref.docstring.tags(:param))
+        end
+        self
+      end
+
+      protected
+
+      attr_writer :block
+
+      attr_writer :signatures
+
+      attr_writer :signature_help
+
+      attr_writer :documentation
+
       private
 
+      # @param name [String]
+      # @param asgn [Boolean]
+      #
+      # @return [::Symbol]
       def select_decl name, asgn
         if name.start_with?('**')
           :kwrestarg
@@ -206,11 +366,16 @@ module Solargraph
         end
       end
 
+      # @param name [String]
+      # @return [String]
       def clean_param name
         name.gsub(/[*&:]/, '')
       end
 
       # @param tag [YARD::Tags::OverloadTag]
+      # @param name [String]
+      #
+      # @return [ComplexType]
       def param_type_from_name(tag, name)
         param = tag.tags(:param).select { |t| t.name == name }.first
         return ComplexType::UNDEFINED unless param
@@ -219,7 +384,7 @@ module Solargraph
 
       # @return [ComplexType]
       def generate_complex_type
-        tags = docstring.tags(:return).map(&:types).flatten.reject(&:nil?)
+        tags = docstring.tags(:return).map(&:types).flatten.compact
         return ComplexType::UNDEFINED if tags.empty?
         ComplexType.try_parse *tags
       end
@@ -250,7 +415,7 @@ module Solargraph
 
       # @param ref [String]
       # @param api_map [ApiMap]
-      # @return [ComplexType]
+      # @return [ComplexType, nil]
       def resolve_reference ref, api_map
         parts = ref.split(/[\.#]/)
         if parts.first.empty? || parts.one?
@@ -285,7 +450,7 @@ module Solargraph
         result = []
         has_nil = false
         return ComplexType::NIL if method_body_node.nil?
-        returns_from(method_body_node).each do |n|
+        returns_from_method_body(method_body_node).each do |n|
           if n.nil? || [:NIL, :nil].include?(n.type)
             has_nil = true
             next
@@ -302,9 +467,11 @@ module Solargraph
         end
         result.push ComplexType::NIL if has_nil
         return ComplexType::UNDEFINED if result.empty?
-        ComplexType.try_parse(*result.map(&:tag).uniq)
+        ComplexType.new(result.uniq)
       end
 
+      # @param [ApiMap] api_map
+      # @return [ComplexType]
       def infer_from_iv api_map
         types = []
         varname = "@#{name.gsub(/=$/, '')}"
@@ -315,14 +482,15 @@ module Solargraph
           types.push type if type.defined?
         end
         return ComplexType::UNDEFINED if types.empty?
-        ComplexType.try_parse(*types.map(&:tag).uniq)
+        ComplexType.new(types.uniq)
       end
 
       # When YARD parses an overload tag, it includes rest modifiers in the parameters names.
       #
-      # @param arg [String]
-      # @return [Array(String, Symbol)]
+      # @param name [String]
+      # @return [::Array(String, ::Symbol)]
       def parse_overload_param(name)
+        # @todo this needs to handle mandatory vs not args, kwargs, blocks, etc
         if name.start_with?('**')
           [name[2..-1], :kwrestarg]
         elsif name.start_with?('*')
@@ -332,6 +500,7 @@ module Solargraph
         end
       end
 
+      # @return [void]
       def concat_example_tags
         example_tags = docstring.tags(:example)
         return if example_tags.empty?
@@ -343,6 +512,10 @@ module Solargraph
         .join("\n")
         .concat("```\n")
       end
+
+      protected
+
+      attr_writer :signatures
     end
   end
 end

data/lib/solargraph/pin/namespace.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'solargraph/yard_tags'
+
 module Solargraph
   module Pin
     class Namespace < Closure
@@ -9,12 +11,10 @@ module Solargraph
       # @return [::Symbol] :class or :module
       attr_reader :type
 
-      attr_reader :parameters
-
       # @param type [::Symbol] :class or :module
       # @param visibility [::Symbol] :public or :private
-      # @param gates [Array<String>]
-      def initialize type: :class, visibility: :public, gates: [''], parameters: [], **splat
+      # @param gates [::Array<String>]
+      def initialize type: :class, visibility: :public, gates: [''], **splat
         # super(location, namespace, name, comments)
         super(**splat)
         @type = type
@@ -38,7 +38,18 @@ module Solargraph
           @closure = Pin::Namespace.new(name: closure_name, gates: [parts.join('::')])
           @context = nil
         end
-        @parameters = parameters
+      end
+
+      def to_rbs
+        "#{@type.to_s} #{return_type.all_params.first.to_rbs}#{rbs_generics}".strip
+      end
+
+      def desc
+        if name.nil? || name.empty?
+          '(top-level)'
+        else
+          to_rbs
+        end
       end
 
       def namespace
@@ -46,7 +57,7 @@ module Solargraph
       end
 
       def full_context
-        @full_context ||= ComplexType.try_parse("#{type.to_s.capitalize}<#{path}>")
+        @full_context ||= ComplexType.try_parse("::#{type.to_s.capitalize}<#{path}>")
       end
 
       def binder
@@ -66,14 +77,16 @@ module Solargraph
         (type == :class ? LanguageServer::SymbolKinds::CLASS : LanguageServer::SymbolKinds::MODULE)
       end
 
+      # @return [String]
       def path
         @path ||= (namespace.empty? ? '' : "#{namespace}::") + name
       end
 
       def return_type
-        @return_type ||= ComplexType.try_parse( (type == :class ? 'Class' : 'Module') + "<#{path}>" )
+        @return_type ||= ComplexType.try_parse( (type == :class ? '::Class' : '::Module') + "<::#{path}>")
       end
 
+      # @return [Array<String>]
       def domains
         @domains ||= []
       end

data/lib/solargraph/pin/parameter.rb

@@ -9,6 +9,9 @@ module Solargraph
       # @return [String]
       attr_reader :asgn_code
 
+      # @param decl [::Symbol] :arg, :optarg, :kwarg, :kwoptarg, :restarg, :kwrestarg, :block, :blockarg
+      # @param asgn_code [String, nil]
+      # @param return_type [ComplexType, nil]
       def initialize decl: :arg, asgn_code: nil, return_type: nil, **splat
         super(**splat)
         @asgn_code = asgn_code
@@ -24,6 +27,10 @@ module Solargraph
         decl == :kwrestarg || (assignment && [:HASH, :hash].include?(assignment.type))
       end
 
+      def arg?
+        decl == :arg
+      end
+
       def restarg?
         decl == :restarg
       end
@@ -36,6 +43,24 @@ module Solargraph
         [:block, :blockarg].include?(decl)
       end
 
+      def to_rbs
+        case decl
+        when :optarg
+          "?#{super}"
+        when :kwarg
+          "#{name}: #{return_type.to_rbs}"
+        when :kwoptarg
+          "?#{name}: #{return_type.to_rbs}"
+        when :restarg
+          "*#{super}"
+        when :kwrestarg
+          "**#{super}"
+        else
+          super
+        end
+      end
+
+      # @return [String]
       def full
         case decl
         when :optarg
@@ -55,6 +80,7 @@ module Solargraph
         end
       end
 
+      # @return [ComplexType]
       def return_type
         if @return_type.nil?
           @return_type = ComplexType::UNDEFINED
@@ -62,11 +88,11 @@ module Solargraph
           @return_type = ComplexType.try_parse(*found.types) unless found.nil? or found.types.nil?
           if @return_type.undefined?
             if decl == :restarg
-              @return_type = ComplexType.try_parse('Array')
+              @return_type = ComplexType.try_parse('::Array')
             elsif decl == :kwrestarg
-              @return_type = ComplexType.try_parse('Hash')
+              @return_type = ComplexType.try_parse('::Hash')
             elsif decl == :blockarg
-              @return_type = ComplexType.try_parse('Proc')
+              @return_type = ComplexType.try_parse('::Proc')
             end
           end
         end
@@ -78,7 +104,9 @@ module Solargraph
       #
       # @return [Integer]
       def index
-        closure.parameter_names.index(name)
+        # @type [Method, Block]
+        method_pin = closure
+        method_pin.parameter_names.index(name)
       end
 
       # @param api_map [ApiMap]
@@ -100,43 +128,20 @@ module Solargraph
 
       private
 
-      # @return [YARD::Tags::Tag]
+      # @return [YARD::Tags::Tag, nil]
       def param_tag
-        found = nil
         params = closure.docstring.tags(:param)
         params.each do |p|
-          next unless p.name == name
-          found = p
-          break
-        end
-        if found.nil? and !index.nil?
-          found = params[index] if params[index] && (params[index].name.nil? || params[index].name.empty?)
+          return p if p.name == name
         end
-        found
+        params[index] if index && params[index] && (params[index].name.nil? || params[index].name.empty?)
       end
 
       # @param api_map [ApiMap]
       # @return [ComplexType]
       def typify_block_param api_map
         if closure.is_a?(Pin::Block) && closure.receiver
-          chain = Parser.chain(closure.receiver, filename)
-          clip = api_map.clip_at(location.filename, location.range.start)
-          locals = clip.locals - [self]
-          meths = chain.define(api_map, closure, locals)
-          meths.each do |meth|
-            if meth.docstring.has_tag?(:yieldparam_single_parameter)
-              type = chain.base.infer(api_map, closure, locals)
-              if type.defined? && !type.subtypes.empty?
-                bmeth = chain.base.define(api_map, closure, locals).first
-                return type.subtypes.first.qualify(api_map, bmeth.context.namespace)
-              end
-            else
-              yps = meth.docstring.tags(:yieldparam)
-              unless yps[index].nil? or yps[index].types.nil? or yps[index].types.empty?
-                return ComplexType.try_parse(yps[index].types.first).self_to(chain.base.infer(api_map, closure, locals).namespace).qualify(api_map, meth.context.namespace)
-              end
-            end
-          end
+          return closure.typify_parameters(api_map)[index]
         end
         ComplexType::UNDEFINED
       end
@@ -144,7 +149,7 @@ module Solargraph
       # @param api_map [ApiMap]
       # @return [ComplexType]
       def typify_method_param api_map
-        meths = api_map.get_method_stack(closure.full_context.namespace, closure.name, scope: closure.scope)
+        meths = api_map.get_method_stack(closure.full_context.tag, closure.name, scope: closure.scope)
         # meths.shift # Ignore the first one
         meths.each do |meth|
           found = nil
@@ -164,8 +169,8 @@ module Solargraph
 
       # @param heredoc [YARD::Docstring]
       # @param api_map [ApiMap]
-      # @param skip [Array]
-      # @return [Array<YARD::Tags::Tag>]
+      # @param skip [::Array]
+      # @return [::Array<YARD::Tags::Tag>]
       def see_reference heredoc, api_map, skip = []
         heredoc.ref_tags.each do |ref|
           next unless ref.tag_name == 'param' && ref.owner
@@ -177,8 +182,8 @@ module Solargraph
 
       # @param ref [String]
       # @param api_map [ApiMap]
-      # @param skip [Array]
-      # @return [Array<YARD::Tags::Tag>, nil]
+      # @param skip [::Array]
+      # @return [::Array<YARD::Tags::Tag>, nil]
       def resolve_reference ref, api_map, skip
         return nil if skip.include?(ref)
         skip.push ref

data/lib/solargraph/pin/proxy_type.rb

@@ -18,7 +18,7 @@ module Solargraph
       def self.anonymous return_type
         parts = return_type.namespace.split('::')
         namespace = parts[0..-2].join('::').to_s
-        name = parts.last.to_s
+        # name = parts.last.to_s
         # ProxyType.new(nil, namespace, name, return_type)
         ProxyType.new(
           closure: Solargraph::Pin::Namespace.new(name: namespace), return_type: return_type

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

@@ -4,10 +4,10 @@ module Solargraph
   module Pin
     class Reference
       class Override < Reference
-        # @return [Array<YARD::Tags::Tag>]
+        # @return [::Array<YARD::Tags::Tag>]
         attr_reader :tags
 
-        # @return [Array<Symbol>]
+        # @return [::Array<Symbol>]
         attr_reader :delete
 
         def initialize location, name, tags, delete = []

data/lib/solargraph/pin/reference.rb

@@ -9,6 +9,14 @@ module Solargraph
       autoload :Prepend,    'solargraph/pin/reference/prepend'
       autoload :Extend,     'solargraph/pin/reference/extend'
       autoload :Override,   'solargraph/pin/reference/override'
+
+      attr_reader :generic_values
+
+      # @param generic_values [Array<String>]
+      def initialize generic_values: [], **splat
+        super(**splat)
+        @generic_values = generic_values
+      end
     end
   end
 end

data/lib/solargraph/pin/search.rb

@@ -18,21 +18,21 @@ module Solargraph
         end
       end
 
-      # @param pins [Array<Pin::Base>]
+      # @param pins [::Array<Pin::Base>]
       # @param query [String]
       def initialize pins, query
         @pins = pins
         @query = query
       end
 
-      # @return [Array<Pin::Base>]
+      # @return [::Array<Pin::Base>]
       def results
         @results ||= do_query
       end
 
       private
 
-      # @return [Array<Pin::Base>]
+      # @return [::Array<Pin::Base>]
       def do_query
         return @pins if @query.nil? || @query.empty?
         @pins.map do |pin|