solargraph 0.47.2 → 0.50.0

data/lib/solargraph/pin/method.rb

@@ -18,13 +18,18 @@ module Solargraph
 
       # @param visibility [::Symbol] :public, :protected, or :private
       # @param explicit [Boolean]
-      def initialize visibility: :public, explicit: true, parameters: [], node: nil, attribute: false, **splat
+      # @param parameters [Array<Pin::Parameter>]
+      # @param node [Parser::AST::Node, RubyVM::AbstractSyntaxTree::Node]
+      # @param attribute [Boolean]
+      def initialize visibility: :public, explicit: true, parameters: [], node: nil, attribute: false, signatures: nil, anon_splat: false, **splat
         super(**splat)
         @visibility = visibility
         @explicit = explicit
         @parameters = parameters
         @node = node
         @attribute = attribute
+        @signatures = signatures
+        @anon_splat = anon_splat
       end
 
       # @return [Array<String>]
@@ -41,7 +46,45 @@ module Solargraph
       end
 
       def return_type
-        @return_type ||= generate_complex_type
+        @return_type ||= ComplexType.try_parse(*signatures.map(&:return_type).map(&:to_s))
+      end
+
+      # @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
+        end
+      end
+
+      # @return [String]
+      def detail
+        # This property is not cached in an instance variable because it can
+        # change when pins get proxied.
+        detail = String.new
+        detail += if signatures.length > 1
+          "(*) "
+        else
+          "(#{signatures.first.parameters.map(&:full).join(', ')}) " unless signatures.first.parameters.empty?
+        end.to_s
+        detail += "=#{probed? ? '~' : (proxied? ? '^' : '>')} #{return_type.to_s}" unless return_type.undefined?
+        detail.strip!
+        return nil if detail.empty?
+        detail
+      end
+
+      # @return [Array<Hash>]
+      def signature_help
+        @signature_help ||= signatures.map do |sig|
+          {
+            label: name + '(' + sig.parameters.map(&:full).join(', ') + ')',
+            documentation: documentation
+          }
+        end
       end
 
       def path
@@ -119,27 +162,60 @@ module Solargraph
       # @return [Array<Pin::Method>]
       def overloads
         @overloads ||= docstring.tags(:overload).map do |tag|
-          Solargraph::Pin::Method.new(
-            name: name,
-            closure: self,
-            # args: tag.parameters.map(&:first),
-            parameters: tag.parameters.map do |src|
+          Pin::Signature.new(
+            tag.parameters.map do |src|
+              name, decl = parse_overload_param(src.first)
               Pin::Parameter.new(
                 location: location,
                 closure: self,
                 comments: tag.docstring.all.to_s,
-                name: src.first,
+                name: name,
+                decl: decl,
                 presence: location ? location.range : nil,
-                decl: :arg
+                return_type: param_type_from_name(tag, src.first)
               )
             end,
-            comments: tag.docstring.all.to_s
+            ComplexType.try_parse(*tag.docstring.tags(:return).flat_map(&:types))
           )
         end
+        @overloads
+      end
+
+      def anon_splat?
+        @anon_splat
       end
 
       private
 
+      def select_decl name, asgn
+        if name.start_with?('**')
+          :kwrestarg
+        elsif name.start_with?('*')
+          :restarg
+        elsif name.start_with?('&')
+          :blockarg
+        elsif name.end_with?(':') && asgn
+          :kwoptarg
+        elsif name.end_with?(':')
+          :kwarg
+        elsif asgn
+          :optarg
+        else
+          :arg
+        end
+      end
+
+      def clean_param name
+        name.gsub(/[*&:]/, '')
+      end
+
+      # @param tag [YARD::Tags::OverloadTag]
+      def param_type_from_name(tag, name)
+        param = tag.tags(:param).select { |t| t.name == name }.first
+        return ComplexType::UNDEFINED unless param
+        ComplexType.try_parse(*param.types)
+      end
+
       # @return [ComplexType]
       def generate_complex_type
         tags = docstring.tags(:return).map(&:types).flatten.reject(&:nil?)
@@ -240,6 +316,20 @@ module Solargraph
         return ComplexType::UNDEFINED if types.empty?
         ComplexType.try_parse(*types.map(&:tag).uniq)
       end
+
+      # When YARD parses an overload tag, it includes rest modifiers in the parameters names.
+      #
+      # @param arg [String]
+      # @return [Array(String, Symbol)]
+      def parse_overload_param(name)
+        if name.start_with?('**')
+          [name[2..-1], :kwrestarg]
+        elsif name.start_with?('*')
+          [name[1..-1], :restarg]
+        else
+          [name, :arg]
+        end
+      end
     end
   end
 end

data/lib/solargraph/pin/namespace.rb

@@ -9,10 +9,12 @@ 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: [''], **splat
+      def initialize type: :class, visibility: :public, gates: [''], parameters: [], **splat
         # super(location, namespace, name, comments)
         super(**splat)
         @type = type
@@ -36,6 +38,7 @@ module Solargraph
           @closure = Pin::Namespace.new(name: closure_name, gates: [parts.join('::')])
           @context = nil
         end
+        @parameters = parameters
       end
 
       def namespace

data/lib/solargraph/pin/parameter.rb

@@ -9,10 +9,11 @@ module Solargraph
       # @return [String]
       attr_reader :asgn_code
 
-      def initialize decl: :arg, asgn_code: nil, **splat
+      def initialize decl: :arg, asgn_code: nil, return_type: nil, **splat
         super(**splat)
         @asgn_code = asgn_code
         @decl = decl
+        @return_type = return_type
       end
 
       def keyword?
@@ -31,14 +32,18 @@ module Solargraph
         decl == :restarg || decl == :kwrestarg
       end
 
+      def block?
+        [:block, :blockarg].include?(decl)
+      end
+
       def full
         case decl
         when :optarg
-          "#{name} = #{asgn_code}"
+          "#{name} = #{asgn_code || '?'}"
         when :kwarg
           "#{name}:"
         when :kwoptarg
-          "#{name}: #{asgn_code}"
+          "#{name}: #{asgn_code || '?'}"
         when :restarg
           "*#{name}"
         when :kwrestarg

data/lib/solargraph/pin/signature.rb

@@ -0,0 +1,23 @@
+module Solargraph
+  module Pin
+    class Signature
+      # @return [Array<Parameter>]
+      attr_reader :parameters
+
+      # @return [ComplexType]
+      attr_reader :return_type
+
+      attr_reader :block
+
+      def initialize parameters, return_type, block = nil
+        @parameters = parameters
+        @return_type = return_type
+        @block = block
+      end
+
+      def block?
+        !!@block
+      end
+    end
+  end
+end

data/lib/solargraph/pin.rb

@@ -10,6 +10,7 @@ module Solargraph
     autoload :Conversions,      'solargraph/pin/conversions'
     autoload :Base,             'solargraph/pin/base'
     autoload :Method,           'solargraph/pin/method'
+    autoload :Signature,        'solargraph/pin/signature'
     autoload :MethodAlias,      'solargraph/pin/method_alias'
     autoload :BaseVariable,     'solargraph/pin/base_variable'
     autoload :InstanceVariable, 'solargraph/pin/instance_variable'

data/lib/solargraph/rbs_map/conversions.rb

@@ -0,0 +1,394 @@
+# frozen_string_literal: true
+
+module Solargraph
+  class RbsMap
+    # Functions for converting RBS declarations to Solargraph pins
+    #
+    module Conversions
+      # A container for tracking the current context of the RBS conversion
+      # process, e.g., what visibility is declared for methods in the current
+      # scope
+      #
+      class Context
+        attr_reader :visibility
+
+        # @param visibility [Symbol]
+        def initialize visibility = :public
+          @visibility = visibility
+        end
+      end
+
+      # @return [Array<Pin::Base>]
+      def pins
+        @pins ||= []
+      end
+
+      private
+
+      def type_aliases
+        @type_aliases ||= {}
+      end
+
+      # @param decl [RBS::AST::Declarations::Base]
+      # @param closure [Pin::Closure]
+      # @return [void]
+      def convert_decl_to_pin decl, closure
+        cursor = pins.length
+        case decl
+        when RBS::AST::Declarations::Class
+          class_decl_to_pin decl
+        when RBS::AST::Declarations::Interface
+          # STDERR.puts "Skipping interface #{decl.name.relative!}"
+          interface_decl_to_pin decl
+        when RBS::AST::Declarations::Alias
+          type_aliases[decl.name.to_s] = decl
+        when RBS::AST::Declarations::Module
+          module_decl_to_pin decl
+        when RBS::AST::Declarations::Constant
+          constant_decl_to_pin decl
+        end
+        pins[cursor..-1].each do |pin|
+          pin.source = :rbs
+          next unless pin.is_a?(Pin::Namespace) && pin.type == :class
+          next if pins.any? { |p| p.path == "#{pin.path}.new"}
+          pins.push Solargraph::Pin::Method.new(
+            location: nil,
+            closure: pin.closure,
+            name: 'new',
+            comments: pin.comments,
+            scope: :class
+          )
+        end
+      end
+
+      def convert_members_to_pin decl, closure
+        context = Context.new
+        decl.members.each { |m| context = convert_member_to_pin(m, closure, context) }
+      end
+
+      def convert_member_to_pin member, closure, context
+        case member
+        when RBS::AST::Members::MethodDefinition
+          method_def_to_pin(member, closure)
+        when RBS::AST::Members::AttrReader
+          attr_reader_to_pin(member, closure)
+        when RBS::AST::Members::AttrWriter
+          attr_writer_to_pin(member, closure)
+        when RBS::AST::Members::AttrAccessor
+          attr_accessor_to_pin(member, closure)
+        when RBS::AST::Members::Include
+          include_to_pin(member, closure)
+        when RBS::AST::Members::Prepend
+          prepend_to_pin(member, closure)
+        when RBS::AST::Members::Extend
+          extend_to_pin(member, closure)
+        when RBS::AST::Members::Alias
+          alias_to_pin(member, closure)
+        when RBS::AST::Members::InstanceVariable
+          ivar_to_pin(member, closure)
+        when RBS::AST::Members::Public
+          return Context.new(visibility: :public)
+        when RBS::AST::Members::Private
+          return Context.new(visibility: :private)
+        when RBS::AST::Declarations::Base
+          convert_decl_to_pin(member, closure)
+        else
+          Solargraph.logger.warn "Skipping member #{member.class}"
+        end
+        context
+      end
+
+      # @param decl [RBS::AST::Declarations::Class]
+      # @return [void]
+      def class_decl_to_pin decl
+        class_pin = Solargraph::Pin::Namespace.new(
+          type: :class,
+          name: decl.name.relative!.to_s,
+          closure: Solargraph::Pin::ROOT_PIN,
+          comments: decl.comment&.string,
+          parameters: decl.type_params.map(&:name).map(&:to_s)
+        )
+        pins.push class_pin
+        if decl.super_class
+          pins.push Solargraph::Pin::Reference::Superclass.new(
+            closure: class_pin,
+            name: decl.super_class.name.relative!.to_s
+          )
+        end
+        convert_members_to_pin decl, class_pin
+      end
+
+      # @param decl [RBS::AST::Declarations::Interface]
+      # @return [void]
+      def interface_decl_to_pin decl
+        class_pin = Solargraph::Pin::Namespace.new(
+          type: :module,
+          name: decl.name.relative!.to_s,
+          closure: Solargraph::Pin::ROOT_PIN,
+          comments: decl.comment&.string,
+          # HACK: Using :hidden to keep interfaces from appearing in
+          # autocompletion
+          visibility: :hidden
+        )
+        class_pin.docstring.add_tag(YARD::Tags::Tag.new(:abstract, '(RBS interface)'))
+        pins.push class_pin
+        convert_members_to_pin decl, class_pin
+      end
+
+      # @param decl [RBS::AST::Declarations::Module]
+      # @return [void]
+      def module_decl_to_pin decl
+        module_pin = Solargraph::Pin::Namespace.new(
+          type: :module,
+          name: decl.name.relative!.to_s,
+          closure: Solargraph::Pin::ROOT_PIN,
+          comments: decl.comment&.string
+        )
+        pins.push module_pin
+        convert_members_to_pin decl, module_pin
+      end
+
+      # @param decl [RBS::AST::Declarations::Constant]
+      # @return [void]
+      def constant_decl_to_pin decl
+        parts = decl.name.relative!.to_s.split('::')
+        if parts.length > 1
+          name = parts.last
+          closure = pins.select { |pin| pin && pin.path == parts[0..-2].join('::') }.first
+        else
+          name = parts.first
+          closure = Solargraph::Pin::ROOT_PIN
+        end
+        pin = Solargraph::Pin::Constant.new(
+          name: name,
+          closure: closure,
+          comments: decl.comment&.string
+        )
+        tag = other_type_to_tag(decl.type)
+        # @todo Class or Module?
+        pin.docstring.add_tag(YARD::Tags::Tag.new(:return, '', "Class<#{tag}>"))
+        pins.push pin
+      end
+
+      # @param decl [RBS::AST::Members::MethodDefinition]
+      # @param closure [Pin::Closure]
+      # @return [void]
+      def method_def_to_pin decl, closure
+        if decl.instance?
+          pin = Solargraph::Pin::Method.new(
+            name: decl.name.to_s,
+            closure: closure,
+            comments: decl.comment&.string,
+            scope: :instance,
+            signatures: []
+          )
+          pin.signatures.concat method_def_to_sigs(decl, pin)
+          pins.push pin
+          if pin.name == 'initialize'
+            pins.push Solargraph::Pin::Method.new(
+              location: pin.location,
+              closure: pin.closure,
+              name: 'new',
+              comments: pin.comments,
+              scope: :class,
+              signatures: pin.signatures
+            )
+            pins.last.signatures.replace(
+              pin.signatures.map do |p|
+                Pin::Signature.new(
+                  p.parameters,
+                  ComplexType::SELF
+                )
+              end
+            )
+            # @todo Is this necessary?
+            # pin.instance_variable_set(:@visibility, :private)
+            # pin.instance_variable_set(:@return_type, ComplexType::VOID)
+          end
+        end
+        if decl.singleton?
+          pin = Solargraph::Pin::Method.new(
+            name: decl.name.to_s,
+            closure: closure,
+            comments: decl.comment&.string,
+            scope: :class,
+            signatures: []
+          )
+          pin.signatures.concat method_def_to_sigs(decl, pin)
+          pins.push pin
+        end
+      end
+
+      # @param decl [RBS::AST::Members::MethodDefinition]
+      # @param pin [Pin::Method]
+      def method_def_to_sigs decl, pin
+        decl.types.map do |type|
+          parameters, return_type = parts_of_function(type, pin)
+          block = if type.block
+            Pin::Signature.new(*parts_of_function(type.block, pin))
+          end
+          return_type = ComplexType.try_parse(method_type_to_tag(type))
+          Pin::Signature.new(parameters, return_type, block)
+        end
+      end
+
+      def parts_of_function type, pin
+        parameters = []
+        arg_num = -1
+        type.type.required_positionals.each do |param|
+          name = param.name ? param.name.to_s : "arg#{arg_num += 1}"
+          parameters.push Solargraph::Pin::Parameter.new(decl: :arg, name: name, closure: pin, return_type: ComplexType.try_parse(other_type_to_tag(param.type)))
+        end
+        type.type.optional_positionals.each do |param|
+          name = param.name ? param.name.to_s : "arg#{arg_num += 1}"
+          parameters.push Solargraph::Pin::Parameter.new(decl: :optarg, name: name, closure: pin)
+        end
+        if type.type.rest_positionals
+          name = type.type.rest_positionals.name ? type.type.rest_positionals.name.to_s : "arg#{arg_num += 1}"
+          parameters.push Solargraph::Pin::Parameter.new(decl: :restarg, name: name, closure: pin)
+        end
+        type.type.trailing_positionals.each do |param|
+          name = param.name ? param.name.to_s : "arg#{arg_num += 1}"
+          parameters.push Solargraph::Pin::Parameter.new(decl: :arg, name: name, closure: pin)
+        end
+        type.type.required_keywords.each do |orig, _param|
+          name = orig ? orig.to_s : "arg#{arg_num += 1}"
+          parameters.push Solargraph::Pin::Parameter.new(decl: :kwarg, name: name, closure: pin)
+        end
+        type.type.optional_keywords.each do |orig, _param|
+          name = orig ? orig.to_s : "arg#{arg_num += 1}"
+          parameters.push Solargraph::Pin::Parameter.new(decl: :kwoptarg, name: name, closure: pin)
+        end
+        if type.type.rest_keywords
+          name = type.type.rest_keywords.name ? type.type.rest_keywords.name.to_s : "arg#{arg_num += 1}"
+          parameters.push Solargraph::Pin::Parameter.new(decl: :kwrestarg, name: type.type.rest_keywords.name.to_s, closure: pin)
+        end
+        return_type = ComplexType.try_parse(method_type_to_tag(type))
+        [parameters, return_type]
+      end
+
+      def attr_reader_to_pin(decl, closure)
+        pin = Solargraph::Pin::Method.new(
+          name: decl.name.to_s,
+          closure: closure,
+          comments: decl.comment&.string,
+          scope: :instance,
+          attribute: true
+        )
+        pin.docstring.add_tag(YARD::Tags::Tag.new(:return, '', other_type_to_tag(decl.type)))
+        pins.push pin
+      end
+
+      def attr_writer_to_pin(decl, closure)
+        pin = Solargraph::Pin::Method.new(
+          name: "#{decl.name.to_s}=",
+          closure: closure,
+          comments: decl.comment&.string,
+          scope: :instance,
+          attribute: true
+        )
+        pin.docstring.add_tag(YARD::Tags::Tag.new(:return, '', other_type_to_tag(decl.type)))
+        pins.push pin
+      end
+
+      def attr_accessor_to_pin(decl, closure)
+        attr_reader_to_pin(decl, closure)
+        attr_writer_to_pin(decl, closure)
+      end
+
+      def ivar_to_pin(decl, closure)
+        pin = Solargraph::Pin::InstanceVariable.new(
+          name: decl.name.to_s,
+          closure: closure,
+          comments: decl.comment&.string
+        )
+        pin.docstring.add_tag(YARD::Tags::Tag.new(:type, '', other_type_to_tag(decl.type)))
+        pins.push pin
+      end
+
+      def include_to_pin decl, closure
+        pins.push Solargraph::Pin::Reference::Include.new(
+          name: decl.name.relative!.to_s,
+          closure: closure
+        )
+      end
+
+      def prepend_to_pin decl, closure
+        pins.push Solargraph::Pin::Reference::Prepend.new(
+          name: decl.name.relative!.to_s,
+          closure: closure
+        )
+      end
+
+      def extend_to_pin decl, closure
+        pins.push Solargraph::Pin::Reference::Extend.new(
+          name: decl.name.relative!.to_s,
+          closure: closure
+        )
+      end
+
+      def alias_to_pin decl, closure
+        pins.push Solargraph::Pin::MethodAlias.new(
+          name: decl.new_name.to_s,
+          original: decl.old_name.to_s,
+          closure: closure
+        )
+      end
+
+      RBS_TO_YARD_TYPE = {
+        'bool' => 'Boolean',
+        'string' => 'String',
+        'int' => 'Integer',
+        'untyped' => '',
+        'NilClass' => 'nil'
+      }
+
+      def method_type_to_tag type
+        if type_aliases.key?(type.type.return_type.to_s)
+          other_type_to_tag(type_aliases[type.type.return_type.to_s].type)
+        else
+          other_type_to_tag type.type.return_type
+        end
+      end
+
+      # @return [String]
+      def other_type_to_tag type
+        if type.is_a?(RBS::Types::Optional)
+          "#{other_type_to_tag(type.type)}, nil"
+        elsif type.is_a?(RBS::Types::Bases::Any)
+          # @todo Not sure what to do with Any yet
+          'BasicObject'
+        elsif type.is_a?(RBS::Types::Bases::Bool)
+          'Boolean'
+        elsif type.is_a?(RBS::Types::Tuple)
+          "Array(#{type.types.map { |t| other_type_to_tag(t) }.join(', ')})"
+        elsif type.is_a?(RBS::Types::Literal)
+          "#{type.literal}"
+        elsif type.is_a?(RBS::Types::Union)
+          type.types.map { |t| other_type_to_tag(t) }.join(', ')
+        elsif type.is_a?(RBS::Types::Record)
+          # @todo Better record support
+          'Hash'
+        elsif type.is_a?(RBS::Types::Bases::Nil)
+          'nil'
+        elsif type.is_a?(RBS::Types::Bases::Self)
+          'self'
+        elsif type.is_a?(RBS::Types::Bases::Void)
+          'void'
+        elsif type.is_a?(RBS::Types::Variable)
+          "param<#{type.name}>"
+        elsif type.is_a?(RBS::Types::ClassInstance) #&& !type.args.empty?
+          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' }
+          return base if params.empty?
+          "#{base}<#{params.join(', ')}>"
+        elsif type.respond_to?(:name) && type.name.respond_to?(:relative!)
+          RBS_TO_YARD_TYPE[type.name.relative!.to_s] || type.name.relative!.to_s
+        else
+          Solargraph.logger.warn "Unrecognized RBS type: #{type.class} #{type}"
+          'undefined'
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/rbs_map/core_fills.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Solargraph
+  class RbsMap
+    # Override pins to fill gaps in RbsMap::CoreMap coverage
+    #
+    module CoreFills
+      Override = Pin::Reference::Override
+
+      KEYWORDS = [
+        '__ENCODING__', '__LINE__', '__FILE__', 'BEGIN', 'END', 'alias', 'and',
+        'begin', 'break', 'case', 'class', 'def', 'defined?', 'do', 'else',
+        'elsif', 'end', 'ensure', 'false', 'for', 'if', 'in', 'module', 'next',
+        'nil', 'not', 'or', 'redo', 'rescue', 'retry', 'return', 'self', 'super',
+        'then', 'true', 'undef', 'unless', 'until', 'when', 'while', 'yield'
+      ].map { |k| Pin::Keyword.new(k) }
+
+      YIELDPARAMS = [
+        Override.from_comment('Object#tap', %(
+@return [self]
+@yieldparam [self]
+        )),
+        Override.from_comment('String#each_line', %(
+@yieldparam [String]
+        )),
+      ]
+
+      methods_with_yieldparam_subtypes = %w[
+        Array#each Array#map Array#map! Array#any? Array#all? Array#index
+        Array#keep_if Array#delete_if
+        Enumerable#each_entry Enumerable#map Enumerable#any? Enumerable#all?
+        Enumerable#select Enumerable#reject
+        Set#each
+      ]
+
+      YIELDPARAM_SINGLE_PARAMETERS = methods_with_yieldparam_subtypes.map do |path|
+        Override.from_comment(path, %(
+@yieldparam_single_parameter
+          ))
+      end
+
+      CLASS_RETURN_TYPES = [
+        Override.method_return('Class#new', 'self'),
+        Override.method_return('Class.new', 'Class<BasicObject>'),
+        Override.method_return('Class#allocate', 'self'),
+        Override.method_return('Class.allocate', 'Class<BasicObject>'),
+      ]
+
+      # HACK: Add Errno exception classes
+      errno = Solargraph::Pin::Namespace.new(name: 'Errno')
+      errnos = []
+      Errno.constants.each do |const|
+        errnos.push Solargraph::Pin::Namespace.new(type: :class, name: const.to_s, closure: errno)
+        errnos.push Solargraph::Pin::Reference::Superclass.new(closure: errnos.last, name: 'SystemCallError')
+      end
+      ERRNOS = errnos
+
+      ALL = KEYWORDS + YIELDPARAMS + YIELDPARAM_SINGLE_PARAMETERS + CLASS_RETURN_TYPES + ERRNOS
+    end
+  end
+end