solargraph 0.52.0 → 0.53.0

data/lib/solargraph/pin/method.rb

@@ -7,7 +7,7 @@ module Solargraph
     class Method < Closure
       include Solargraph::Parser::NodeMethods
 
-      # @return [Array<Pin::Parameter>]
+      # @return [::Array<Pin::Parameter>]
       attr_reader :parameters
 
       # @return [::Symbol] :public, :private, or :protected
@@ -18,21 +18,66 @@ module Solargraph
 
       # @param visibility [::Symbol] :public, :protected, or :private
       # @param explicit [Boolean]
-      # @param parameters [Array<Pin::Parameter>]
+      # @param parameters [::Array<Pin::Parameter>]
+      # @param block [Pin::Signature, nil, ::Symbol]
       # @param node [Parser::AST::Node, RubyVM::AbstractSyntaxTree::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]
+      # @param return_type [ComplexType, nil]
+      def initialize visibility: :public, explicit: true, parameters: [], block: :undefined, node: nil, attribute: false, signatures: nil, anon_splat: false, return_type: nil, **splat
         super(**splat)
         @visibility = visibility
         @explicit = explicit
         @parameters = parameters
+        @block = block
         @node = node
         @attribute = attribute
         @signatures = signatures
         @anon_splat = anon_splat
+        @return_type = return_type
       end
 
-      # @return [Array<String>]
+      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.parameters = m.parameters.map do |param|
+          param.transform_types(&transform)
+        end
+        m.block = block&.transform_types(&transform)
+        m.signature_help = nil
+        m.documentation = nil
+        m
+      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
+
+      # @return [Pin::Signature, nil]
+      def block
+        return @block unless @block == :undefined
+        @block = signatures.first.block
+      end
+
+      # @return [::Array<String>]
       def parameter_names
         @parameter_names ||= parameters.map(&:name)
       end
@@ -49,11 +94,14 @@ module Solargraph
         @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
@@ -75,12 +123,12 @@ module Solargraph
             )
           end
           yield_return_type = ComplexType.try_parse(*yieldreturn_tags.flat_map(&:types))
-          block = Signature.new(yield_parameters, yield_return_type)
+          block = Signature.new(generics, yield_parameters, yield_return_type)
         end
-        Signature.new(parameters, return_type, block)
+        Signature.new(generics, parameters, return_type, block)
       end
 
-      # @return [Array<Signature>]
+      # @return [::Array<Signature>]
       def signatures
         @signatures ||= begin
           top_type = generate_complex_type
@@ -92,7 +140,7 @@ module Solargraph
         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.
@@ -108,7 +156,7 @@ module Solargraph
         detail
       end
 
-      # @return [Array<Hash>]
+      # @return [::Array<Hash>]
       def signature_help
         @signature_help ||= signatures.map do |sig|
           {
@@ -118,6 +166,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
@@ -217,10 +286,11 @@ module Solargraph
         true
       end
 
-      # @return [Array<Pin::Method>]
+      # @return [::Array<Pin::Method>]
       def overloads
         @overloads ||= docstring.tags(:overload).map do |tag|
           Pin::Signature.new(
+            generics,
             tag.parameters.map do |src|
               name, decl = parse_overload_param(src.first)
               Pin::Parameter.new(
@@ -243,8 +313,24 @@ module Solargraph
         @anon_splat
       end
 
+      protected
+
+      attr_writer :block
+
+      attr_writer :parameters
+
+      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
@@ -263,11 +349,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
@@ -276,7 +367,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
@@ -307,7 +398,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?
@@ -342,7 +433,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
@@ -362,6 +453,8 @@ module Solargraph
         ComplexType.try_parse(*result.map(&:tag).uniq)
       end
 
+      # @param [ApiMap] api_map
+      # @return [ComplexType]
       def infer_from_iv api_map
         types = []
         varname = "@#{name.gsub(/=$/, '')}"
@@ -377,8 +470,8 @@ module Solargraph
 
       # 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)
         if name.start_with?('**')
           [name[2..-1], :kwrestarg]
@@ -389,6 +482,7 @@ module Solargraph
         end
       end
 
+      # @return [void]
       def concat_example_tags
         example_tags = docstring.tags(:example)
         return if example_tags.empty?

data/lib/solargraph/pin/namespace.rb

@@ -11,12 +11,10 @@ module Solargraph
       # @return [::Symbol] :class or :module
       attr_reader :type
 
-      attr_reader :generics
-
       # @param type [::Symbol] :class or :module
       # @param visibility [::Symbol] :public or :private
-      # @param gates [Array<String>]
-      def initialize type: :class, visibility: :public, gates: [''], generics: nil, **splat
+      # @param gates [::Array<String>]
+      def initialize type: :class, visibility: :public, gates: [''], **splat
         # super(location, namespace, name, comments)
         super(**splat)
         @type = type
@@ -40,7 +38,18 @@ module Solargraph
           @closure = Pin::Namespace.new(name: closure_name, gates: [parts.join('::')])
           @context = nil
         end
-        @generics = generics
+      end
+
+      def to_rbs
+        "#{@type.to_s} #{generics_as_rbs}#{return_type.to_rbs}"
+      end
+
+      def desc
+        if name.nil?
+          '(top-level)'
+        else
+          to_rbs
+        end
       end
 
       def namespace
@@ -68,6 +77,7 @@ module Solargraph
         (type == :class ? LanguageServer::SymbolKinds::CLASS : LanguageServer::SymbolKinds::MODULE)
       end
 
+      # @return [String]
       def path
         @path ||= (namespace.empty? ? '' : "#{namespace}::") + name
       end
@@ -76,6 +86,7 @@ module Solargraph
         @return_type ||= ComplexType.try_parse( (type == :class ? 'Class' : 'Module') + "<#{path}>" )
       end
 
+      # @return [Array<String>]
       def domains
         @domains ||= []
       end
@@ -91,11 +102,6 @@ module Solargraph
           [path] + @open_gates
         end
       end
-
-      # @return [Array<String>]
-      def generics
-        @generics ||= docstring.tags(:generic).map(&:name)
-      end
     end
   end
 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
@@ -36,6 +39,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
@@ -100,7 +121,7 @@ module Solargraph
 
       private
 
-      # @return [YARD::Tags::Tag]
+      # @return [YARD::Tags::Tag, nil]
       def param_tag
         found = nil
         params = closure.docstring.tags(:param)
@@ -119,15 +140,25 @@ module Solargraph
       # @return [ComplexType]
       def typify_block_param api_map
         if closure.is_a?(Pin::Block) && closure.receiver
-          chain = Parser.chain(closure.receiver, filename)
+          chain = Parser.chain(closure.receiver, filename, closure.node)
           clip = api_map.clip_at(location.filename, location.range.start)
           locals = clip.locals - [self]
           meths = chain.define(api_map, closure, locals)
           receiver_type = chain.base.infer(api_map, closure, locals)
           meths.each do |meth|
-            yps = meth.docstring.tags(:yieldparam)
-            unless yps[index].nil? or yps[index].types.nil? or yps[index].types.empty?
-              yield_type = ComplexType.try_parse(yps[index].types.first)
+            block_signature = meth.block
+            if block_signature
+              yield_type = block_signature.parameters[index]&.return_type
+            else
+              # @todo move the yieldparam tag parsing logic into the
+              #   creation of Method pins so we don't need this else
+              #   statement
+              yps = meth.docstring.tags(:yieldparam)
+              unless yps[index].nil? or yps[index].types.nil? or yps[index].types.empty?
+                yield_type = ComplexType.try_parse(yps[index].types.first)
+              end
+            end
+            unless yield_type.nil?
               if yield_type.generic? && receiver_type.defined?
                 namespace_pin = api_map.get_namespace_pins(meth.namespace, closure.namespace).first
                 return yield_type.resolve_generics(namespace_pin, receiver_type)
@@ -143,7 +174,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
@@ -163,8 +194,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
@@ -176,8 +207,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/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|

data/lib/solargraph/pin/signature.rb

@@ -1,7 +1,7 @@
 module Solargraph
   module Pin
     class Signature < Base
-      # @return [Array<Parameter>]
+      # @return [::Array<Parameter>]
       attr_reader :parameters
 
       # @return [ComplexType]
@@ -10,15 +10,121 @@ module Solargraph
       # @return [self]
       attr_reader :block
 
+      # @param generics [Array<String>]
       # @param parameters [Array<Parameter>]
       # @param return_type [ComplexType]
       # @param block [Signature, nil]
-      def initialize parameters, return_type, block = nil
+      def initialize generics, parameters, return_type, block = nil
+        @generics = generics
         @parameters = parameters
         @return_type = return_type
         @block = block
       end
 
+      def generics
+        @generics ||= [].freeze
+      end
+
+      # @return [String]
+      def to_rbs
+        rbs_generics + '(' + parameters.map { |param| param.to_rbs }.join(', ') + ') ' + (block.nil? ? '' : '{ ' + block.to_rbs + ' } ') + '-> ' + return_type.to_rbs
+      end
+
+      # @return [String]
+      def rbs_generics
+        if generics.empty?
+          return ''
+        else
+          return '[' + generics.map { |gen| gen.to_s }.join(', ') + '] '
+        end
+      end
+
+      # @return [Array<String>]
+      # @yieldparam [ComplexType]
+      # @yieldreturn [ComplexType]
+      # @return [self]
+      def transform_types(&transform)
+        # @todo 'super' alone should work here I think, but doesn't typecheck at level typed
+        signature = super(&transform)
+        signature.parameters = signature.parameters.map do |param|
+          param.transform_types(&transform)
+        end
+        signature.block = block.transform_types(&transform) if signature.block?
+        signature
+      end
+
+      # @param generics_to_resolve [Enumerable<String>]
+      # @param arg_types [Array<ComplexType>, nil]
+      # @param return_type_context [ComplexType, nil]
+      # @param yield_arg_types [Array<ComplexType>, nil]
+      # @param yield_return_type_context [ComplexType, nil]
+      # @param context [ComplexType, nil]
+      # @param resolved_generic_values [Hash{String => ComplexType}]
+      # @return [self]
+      def resolve_generics_from_context(generics_to_resolve,
+                                        arg_types = nil,
+                                        return_type_context = nil,
+                                        yield_arg_types = nil,
+                                        yield_return_type_context = nil,
+                                        resolved_generic_values: {})
+        signature = super(generics_to_resolve, return_type_context, resolved_generic_values: resolved_generic_values)
+        signature.parameters = signature.parameters.each_with_index.map do |param, i|
+          if arg_types.nil?
+            param.dup
+          else
+            param.resolve_generics_from_context(generics_to_resolve,
+                                                arg_types[i],
+                                                resolved_generic_values: resolved_generic_values)
+          end
+        end
+        signature.block = block.resolve_generics_from_context(generics_to_resolve,
+                                                              yield_arg_types,
+                                                              yield_return_type_context,
+                                                              resolved_generic_values: resolved_generic_values) if signature.block?
+        signature
+      end
+
+      # @param generics_to_resolve [Enumerable<String>]
+      # @param arg_types [Array<ComplexType>, nil]
+      # @param return_type_context [ComplexType, nil]
+      # @param yield_arg_types [Array<ComplexType>, nil]
+      # @param yield_return_type_context [ComplexType, nil]
+      # @param context [ComplexType, nil]
+      # @param resolved_generic_values [Hash{String => ComplexType}]
+      # @return [self]
+      def resolve_generics_from_context_until_complete(generics_to_resolve,
+                                                       arg_types = nil,
+                                                       return_type_context = nil,
+                                                       yield_arg_types = nil,
+                                                       yield_return_type_context = nil,
+                                                       resolved_generic_values: {})
+        # See
+        # https://github.com/soutaro/steep/tree/master/lib/steep/type_inference
+        # and
+        # https://github.com/sorbet/sorbet/blob/master/infer/inference.cc
+        # for other implementations
+
+        return self if generics_to_resolve.empty?
+
+        last_resolved_generic_values = resolved_generic_values.dup
+        new_pin = resolve_generics_from_context(generics_to_resolve,
+                                                arg_types,
+                                                return_type_context,
+                                                yield_arg_types,
+                                                yield_return_type_context,
+                                                resolved_generic_values: resolved_generic_values)
+        if last_resolved_generic_values == resolved_generic_values
+          # erase anything unresolved
+          return new_pin.erase_generics(self.generics)
+        end
+        new_pin.resolve_generics_from_context_until_complete(generics_to_resolve,
+                                                             arg_types,
+                                                             return_type_context,
+                                                             yield_arg_types,
+                                                             yield_return_type_context,
+                                                             resolved_generic_values: resolved_generic_values)
+      end
+
       def identity
         @identity ||= "signature#{object_id}"
       end
@@ -26,6 +132,12 @@ module Solargraph
       def block?
         !!@block
       end
+
+      protected
+
+      attr_writer :block
+
+      attr_writer :parameters
     end
   end
 end

data/lib/solargraph/pin.rb

@@ -27,7 +27,6 @@ module Solargraph
     autoload :Reference,        'solargraph/pin/reference'
     autoload :Documenting,      'solargraph/pin/documenting'
     autoload :Block,            'solargraph/pin/block'
-    autoload :Localized,        'solargraph/pin/localized'
     autoload :ProxyType,        'solargraph/pin/proxy_type'
     autoload :DuckMethod,       'solargraph/pin/duck_method'
     autoload :Singleton,        'solargraph/pin/singleton'

data/lib/solargraph/range.rb

@@ -62,8 +62,8 @@ module Solargraph
 
     # Get a range from a node.
     #
-    # @param node [RubyVM::AbstractSyntaxTree::Node, Parser::AST::Node]
-    # @return [Range]
+    # @param node [Parser::AST::Node]
+    # @return [Range, nil]
     def self.from_node node
       if Parser.rubyvm? && node.is_a?(RubyVM::AbstractSyntaxTree::Node)
         Solargraph::Range.from_to(node.first_lineno - 1, node.first_column, node.last_lineno - 1, node.last_column)