solargraph 0.44.3 → 0.49.0

data/lib/solargraph/parser/rubyvm/node_processors/defs_node.rb

@@ -11,6 +11,8 @@ module Solargraph
             s_visi = region.visibility
             s_visi = :public if region.scope != :class
             loc = get_node_location(node)
+            anon_splat = node_has_anon_splat?
+
             if node.children[0].is_a?(RubyVM::AbstractSyntaxTree::Node) && node.children[0].type == :SELF
               closure = region.closure
             else
@@ -26,7 +28,8 @@ module Solargraph
                 comments: comments_for(node),
                 scope: :class,
                 visibility: :public,
-                node: node
+                node: node,
+                anon_splat: anon_splat
               )
               pins.push Solargraph::Pin::Method.new(
                 location: loc,
@@ -35,7 +38,8 @@ module Solargraph
                 comments: comments_for(node),
                 scope: :instance,
                 visibility: :private,
-                node: node
+                node: node,
+                anon_splat: anon_splat
               )
             else
               pins.push Solargraph::Pin::Method.new(
@@ -45,11 +49,18 @@ module Solargraph
                 comments: comments_for(node),
                 scope: :class,
                 visibility: s_visi,
-                node: node
+                node: node,
+                anon_splat: anon_splat
               )
             end
             process_children region.update(closure: pins.last, scope: :class)
           end
+
+          private
+
+          def node_has_anon_splat?
+            node.children[2]&.children&.first == [nil]
+          end
         end
       end
     end

data/lib/solargraph/parser/rubyvm/node_processors/kw_arg_node.rb

@@ -11,8 +11,8 @@ module Solargraph
               closure: region.closure,
               comments: comments_for(node),
               name: node.children[0].children[0].to_s,
-              # assignment: require_keyword?(node) ? nil : node.children[0].children[1],
-              asgn_code: require_keyword?(node) ? nil: region.code_for(node.children[0].children[1]),
+              assignment: require_keyword?(node) ? nil : node.children[0].children[1],
+              asgn_code: require_keyword?(node) ? nil : region.code_for(node.children[0].children[1]),
               presence: region.closure.location.range,
               decl: require_keyword?(node) ? :kwarg : :kwoptarg
             )

data/lib/solargraph/parser/rubyvm/node_processors/sclass_node.rb

@@ -6,11 +6,22 @@ module Solargraph
       module NodeProcessors
         class SclassNode < Parser::NodeProcessor::Base
           def process
-            # @todo Temporarily skipping remote metaclasses
-            return unless node.children[0].is_a?(RubyVM::AbstractSyntaxTree::Node) && node.children[0].type == :SELF
+            sclass = node.children[0]
+            if sclass.is_a?(RubyVM::AbstractSyntaxTree::Node) && sclass.type == :SELF
+              closure = region.closure
+            elsif sclass.is_a?(RubyVM::AbstractSyntaxTree::Node) && %i[CDECL CONST].include?(sclass.type)
+              names = [region.closure.namespace, region.closure.name]
+              if names.last != sclass.children[0].to_s
+                names << sclass.children[0].to_s
+              end
+              name = names.reject(&:empty?).join('::')
+              closure = Solargraph::Pin::Namespace.new(name: name, location: region.closure.location)
+            else
+              return
+            end
             pins.push Solargraph::Pin::Singleton.new(
               location: get_node_location(node),
-              closure: region.closure
+              closure: closure
             )
             process_children region.update(visibility: :public, scope: :class, closure: pins.last)
           end

data/lib/solargraph/parser/rubyvm/node_processors/send_node.rb

@@ -226,8 +226,10 @@ module Solargraph
 
           # @return [void]
           def process_private_constant
-            return unless Parser.is_ast_node?(node.children.last)
-            node.children.last.children[0..-2].each do |child|
+            arr = node.children[1]
+            return unless Parser.is_ast_node?(arr) && [:ARRAY, :LIST].include?(arr.type)
+
+            arr.children.compact.each do |child|
               if [:LIT, :STR].include?(child.type)
                 cn = child.children[0].to_s
                 ref = pins.select{|p| [Solargraph::Pin::Namespace, Solargraph::Pin::Constant].include?(p.class) && p.namespace == region.closure.full_context.namespace && p.name == cn}.first

data/lib/solargraph/parser/rubyvm/node_processors.rb

@@ -45,6 +45,7 @@ module Solargraph
       register :IASGN,      Rubyvm::NodeProcessors::IvasgnNode
       register :CVASGN,     Rubyvm::NodeProcessors::CvasgnNode
       register :LASGN,      Rubyvm::NodeProcessors::LvasgnNode
+      register :DASGN,      Rubyvm::NodeProcessors::LvasgnNode
       register :DASGN_CURR, Rubyvm::NodeProcessors::LvasgnNode
       register :GASGN,      Rubyvm::NodeProcessors::GvasgnNode
       register :CDECL,      Rubyvm::NodeProcessors::CasgnNode

data/lib/solargraph/parser/rubyvm/node_wrapper.rb

@@ -0,0 +1,47 @@
+require 'delegate'
+
+module RubyVM::AbstractSyntaxTree
+  # Wrapper for RubyVM::AbstractSyntaxTree::Node. for return character based column
+  class NodeWrapper < SimpleDelegator
+    attr_reader :code
+    # @param node [RubyVM::AbstractSyntaxTree::Node] wrapped node to return character based column
+    # @param code [Array<String>] source code lines for generated this node
+    def initialize(node, code)
+      @code = code
+      super(node)
+    end
+
+    def self.from(node, code)
+      return node unless node.is_a?(RubyVM::AbstractSyntaxTree::Node) and !node.kind_of?(SimpleDelegator)
+
+      new(node, code)
+    end
+
+    def is_a?(type)
+      __getobj__.is_a?(type) || super.is_a?(type)
+    end
+
+    def class
+      __getobj__.class
+    end
+
+
+    def first_column
+      @first_column ||= begin
+        line = @code[__getobj__.first_lineno - 1] || ""
+        line.byteslice(0, __getobj__.first_column).length
+      end
+    end
+
+    def last_column
+      @last_column ||= begin
+        line = @code[__getobj__.last_lineno - 1] || ""
+        line.byteslice(0, __getobj__.last_column).length
+      end
+    end
+
+    def children
+      @children ||= __getobj__.children.map do |node| NodeWrapper.from(node, @code) end
+    end
+  end
+end

data/lib/solargraph/pin/base.rb

@@ -21,9 +21,12 @@ module Solargraph
       # @return [String]
       attr_reader :path
 
-      # @param location [Solargraph::Location]
+      # @return [::Symbol]
+      attr_accessor :source
+
+      # @param location [Solargraph::Location, nil]
       # @param kind [Integer]
-      # @param closure [Solargraph::Pin::Closure]
+      # @param closure [Solargraph::Pin::Closure, nil]
       # @param name [String]
       # @param comments [String]
       def initialize location: nil, closure: nil, name: '', comments: ''

data/lib/solargraph/pin/block.rb

@@ -8,6 +8,7 @@ module Solargraph
       # @return [Parser::AST::Node]
       attr_reader :receiver
 
+      # @param args [Array<Parameter>]
       def initialize receiver: nil, args: [], context: nil, **splat
         super(**splat)
         @receiver = receiver
@@ -25,7 +26,7 @@ module Solargraph
         @binder || closure.binder
       end
 
-      # @return [Array<String>]
+      # @return [Array<Parameter>]
       def parameters
         @parameters ||= []
       end

data/lib/solargraph/pin/conversions.rb

@@ -34,12 +34,9 @@ module Solargraph
         end
       end
 
-      # @return [Hash]
+      # @return [Array<Hash>]
       def signature_help
-        @signature_help ||= {
-          label: name + '(' + parameters.map(&:full).join(', ') + ')',
-          documentation: documentation
-        }
+        []
       end
 
       # @return [String]
@@ -47,7 +44,6 @@ module Solargraph
         # This property is not cached in an instance variable because it can
         # change when pins get proxied.
         detail = String.new
-        detail += "(#{parameters.map(&:full).join(', ')}) " unless !is_a?(Pin::Method) || parameters.empty?
         detail += "=#{probed? ? '~' : (proxied? ? '^' : '>')} #{return_type.to_s}" unless return_type.undefined?
         detail.strip!
         return nil if detail.empty?

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

@@ -3,14 +3,17 @@
 module Solargraph
   module Pin
     class Parameter < LocalVariable
+      # @return [Symbol]
       attr_reader :decl
 
+      # @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?
@@ -29,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
@@ -91,10 +98,6 @@ module Solargraph
         true
       end
 
-      def probe api_map
-        typify api_map
-      end
-
       private
 
       # @return [YARD::Tags::Tag]

data/lib/solargraph/pin/search.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require 'jaro_winkler'
+
+module Solargraph
+  module Pin
+    class Search
+      class Result
+        # @return [Float]
+        attr_reader :match
+
+        # @return [Pin::Base]
+        attr_reader :pin
+
+        def initialize match, pin
+          @match = match
+          @pin = pin
+        end
+      end
+
+      # @param pins [Array<Pin::Base>]
+      # @param query [String]
+      def initialize pins, query
+        @pins = pins
+        @query = query
+      end
+
+      # @return [Array<Pin::Base>]
+      def results
+        @results ||= do_query
+      end
+
+      private
+
+      # @return [Array<Pin::Base>]
+      def do_query
+        return @pins if @query.nil? || @query.empty?
+        @pins.map do |pin|
+          match = [fuzzy_string_match(pin.path, @query), fuzzy_string_match(pin.name, @query)].max
+          Result.new(match, pin) if match > 0.7
+        end
+          .compact
+          .sort { |a, b| b.match <=> a.match }
+          .map(&:pin)
+      end
+
+      # @param str1 [String]
+      # @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)
+        JaroWinkler.distance(str1, str2, ignore_case: true)
+      end
+    end
+  end
+end

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'
@@ -30,6 +31,7 @@ module Solargraph
     autoload :DuckMethod,       'solargraph/pin/duck_method'
     autoload :Singleton,        'solargraph/pin/singleton'
     autoload :KeywordParam,     'solargraph/pin/keyword_param'
+    autoload :Search,           'solargraph/pin/search'
 
     ROOT_PIN = Pin::Namespace.new(type: :class, name: '', closure: nil)
   end

data/lib/solargraph/range.rb

@@ -69,7 +69,7 @@ module Solargraph
         if node.is_a?(RubyVM::AbstractSyntaxTree::Node)
           Solargraph::Range.from_to(node.first_lineno - 1, node.first_column, node.last_lineno - 1, node.last_column)
         end
-      elsif node.loc && node.loc.expression
+      elsif node&.loc && node.loc.expression
         from_expr(node.loc.expression)
       end
     end