solargraph 0.38.6 → 0.39.0

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

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Parser
+    module Rubyvm
+      module NodeProcessors
+        class SymNode < Parser::NodeProcessor::Base
+          def process
+            pins.push Solargraph::Pin::Symbol.new(
+              get_node_location(node),
+              ":#{node.children[0]}"
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/parser/snippet.rb

@@ -0,0 +1,13 @@
+module Solargraph
+  module Parser
+    class Snippet
+      attr_reader :range
+      attr_reader :text
+
+      def initialize range, text
+        @range = range
+        @text = text
+      end
+    end
+  end
+end

data/lib/solargraph/pin/attribute.rb

@@ -10,6 +10,14 @@ module Solargraph
       def initialize access: :reader, **splat
         super(splat)
         @access = access
+        if access == :writer
+          parameters.push(
+            Pin::Parameter.new(name: 'value', decl: :arg, closure: self)
+          )
+          if return_type.defined?
+            docstring.add_tag YARD::Tags::Tag.new(:param, '', return_type.to_s.split(', '), 'value')
+          end
+        end
       end
 
       def completion_item_kind

data/lib/solargraph/pin/base.rb

@@ -49,7 +49,7 @@ module Solargraph
         LanguageServer::CompletionItemKinds::KEYWORD
       end
 
-      # @return [Integer]
+      # @return [Integer, nil]
       def symbol_kind
         nil
       end

data/lib/solargraph/pin/base_method.rb

@@ -8,10 +8,15 @@ module Solargraph
       # @return [::Symbol] :public, :private, or :protected
       attr_reader :visibility
 
+      # @return [Parser::AST::Node]
+      attr_reader :node
+
       # @param visibility [::Symbol] :public, :protected, or :private
-      def initialize visibility: :public, **splat
+      # @param explicit [Boolean]
+      def initialize visibility: :public, explicit: true, **splat
         super(splat)
         @visibility = visibility
+        @explicit = explicit
       end
 
       def return_type
@@ -30,14 +35,14 @@ module Solargraph
         name.end_with?('?') ? ComplexType::BOOLEAN : ComplexType::UNDEFINED
       end
 
-      # @return [Array<String>]
+      # @return [Array<Pin::Parameter>]
       def parameters
-        []
+        @parameters ||= []
       end
 
       # @return [Array<String>]
       def parameter_names
-        []
+        parameters.map(&:name)
       end
 
       def documentation
@@ -56,12 +61,29 @@ module Solargraph
             end
             @documentation += lines.join("\n")
           end
+          return_tags = docstring.tags(:return)
+          unless return_tags.empty?
+            @documentation += "\n\n" unless @documentation.empty?
+            @documentation += "Returns:\n"
+            lines = []
+            return_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
           @documentation += "\n\n" unless @documentation.empty?
           @documentation += "Visibility: #{visibility}"
         end
         @documentation.to_s
       end
 
+      def explicit?
+        @explicit
+      end
+
       private
 
       # @return [ComplexType]

data/lib/solargraph/pin/base_variable.rb

@@ -3,7 +3,8 @@
 module Solargraph
   module Pin
     class BaseVariable < Base
-      include Solargraph::Source::NodeMethods
+      include Solargraph::Parser::NodeMethods
+      # include Solargraph::Source::NodeMethods
 
       # @return [Parser::AST::Node, nil]
       attr_reader :assignment
@@ -14,10 +15,6 @@ module Solargraph
         @assignment = assignment
       end
 
-      def signature
-        @signature ||= resolve_node_signature(@assignment)
-      end
-
       def completion_item_kind
         Solargraph::LanguageServer::CompletionItemKinds::VARIABLE
       end
@@ -44,14 +41,16 @@ module Solargraph
         types = []
         returns_from(@assignment).each do |node|
           # Nil nodes may not have a location
-          if node.type == :nil
+          if node.nil? || node.type == :NIL || node.type == :nil
             types.push ComplexType::NIL
           else
-            pos = Solargraph::Position.new(node.loc.expression.last_line, node.loc.expression.last_column)
+            rng = Range.from_node(node)
+            next if rng.nil?
+            pos = rng.ending
             clip = api_map.clip_at(location.filename, pos)
             # Use the return node for inference. The clip might infer from the
             # first node in a method call instead of the entire call.
-            chain = Solargraph::Source::NodeChainer.chain(node, nil, clip.in_block?)
+            chain = Parser.chain(node, nil, clip.in_block?)
             result = chain.infer(api_map, closure, clip.locals)
             types.push result unless result.undefined?
           end

data/lib/solargraph/pin/block.rb

@@ -34,7 +34,7 @@ module Solargraph
 
       # @return [Array<String>]
       def parameter_names
-        @parameter_names ||= parameters.map{|p| p.split(/[ =:]/).first.gsub(/^(\*{1,2}|&)/, '')}
+        @parameter_names ||= parameters.map(&:name)
       end
 
       def nearly? other

data/lib/solargraph/pin/constant.rb

@@ -10,6 +10,10 @@ module Solargraph
         @visibility = visibility
       end
 
+      def return_type
+        @return_type ||= generate_complex_type
+      end
+
       def completion_item_kind
         Solargraph::LanguageServer::CompletionItemKinds::CONSTANT
       end
@@ -22,6 +26,18 @@ module Solargraph
       def path
         @path ||= context.namespace.to_s.empty? ? name : "#{context.namespace}::#{name}"
       end
+
+      private
+
+      # @return [ComplexType]
+      def generate_complex_type
+        tags = docstring.tags(:return).map(&:types).flatten.reject(&:nil?)
+        if tags.empty?
+          tags = docstring.tags(:type).map(&:types).flatten.reject(&:nil?)
+        end
+        return ComplexType::UNDEFINED if tags.empty?
+        ComplexType.try_parse *tags
+      end
     end
   end
 end

data/lib/solargraph/pin/conversions.rb

@@ -38,7 +38,7 @@ module Solargraph
       # @return [Hash]
       def signature_help
         @signature_help ||= {
-          label: name + '(' + parameters.join(', ') + ')',
+          label: name + '(' + parameters.map(&:full).join(', ') + ')',
           documentation: documentation
         }
       end
@@ -48,7 +48,7 @@ module Solargraph
         # This property is not cached in an instance variable because it can
         # change when pins get proxied.
         detail = String.new
-        detail += "(#{parameters.join(', ')}) " unless !is_a?(Pin::BaseMethod) or parameters.empty?
+        detail += "(#{parameters.map(&:full).join(', ')}) " unless !is_a?(Pin::BaseMethod) || 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

@@ -3,25 +3,22 @@
 module Solargraph
   module Pin
     class Method < BaseMethod
-      include Source::NodeMethods
+      include Solargraph::Parser::NodeMethods
 
       # @return [Array<String>]
       attr_reader :parameters
 
-      # @return [Parser::AST::Node]
-      attr_reader :node
-
       # @param args [Array<String>]
       # @param node [Parser::AST::Node, nil]
-      def initialize args: [], node: nil, **splat
+      def initialize parameters: [], node: nil, **splat
         super(splat)
-        @parameters = args
+        @parameters = parameters
         @node = node
       end
 
       # @return [Array<String>]
       def parameter_names
-        @parameter_names ||= parameters.map{|p| p.split(/[ =:]/).first.gsub(/^(\*{1,2}|&)/, '')}
+        @parameter_names ||= parameters.map(&:name)
       end
 
       def completion_item_kind
@@ -54,8 +51,18 @@ module Solargraph
         @overloads ||= docstring.tags(:overload).map do |tag|
           Solargraph::Pin::Method.new(
             name: name,
-            closure: closure,
-            args: tag.parameters.map(&:first),
+            closure: self,
+            # args: tag.parameters.map(&:first),
+            parameters: tag.parameters.map do |src|
+              Pin::Parameter.new(
+                location: location,
+                closure: self,
+                comments: tag.docstring.all.to_s,
+                name: src.first,
+                presence: location ? location.range : nil,
+                decl: :arg
+              )
+            end,
             comments: tag.docstring.all.to_s
           )
         end
@@ -66,7 +73,9 @@ module Solargraph
       # @return [Parser::AST::Node, nil]
       def method_body_node
         return nil if node.nil?
-        return node.children[2] if node.type == :def
+        return node.children[1].children.last if node.type == :DEFN
+        return node.children[2].children.last if node.type == :DEFS
+        return node.children[2] if node.type == :def || node.type == :DEFS
         return node.children[3] if node.type == :defs
         nil
       end
@@ -74,19 +83,22 @@ module Solargraph
       # @param api_map [ApiMap]
       # @return [ComplexType]
       def infer_from_return_nodes api_map
+        return ComplexType::UNDEFINED if node.nil?
         result = []
         has_nil = false
+        return ComplexType::NIL if method_body_node.nil?
         returns_from(method_body_node).each do |n|
-          if n.nil? || n.type == :nil
+          if n.nil? || [:NIL, :nil].include?(n.type)
             has_nil = true
             next
           end
-          next if n.loc.nil? || n.loc.expression.nil?
+          rng = Range.from_node(n)
+          next unless rng
           clip = api_map.clip_at(
             location.filename,
-            [n.loc.expression.last_line, n.loc.expression.last_column]
+            rng.ending
           )
-          chain = Solargraph::Source::NodeChainer.chain(n, location.filename)
+          chain = Solargraph::Parser.chain(n, location.filename)
           type = chain.infer(api_map, self, clip.locals)
           result.push type unless type.undefined?
         end

data/lib/solargraph/pin/parameter.rb

@@ -3,11 +3,65 @@
 module Solargraph
   module Pin
     class Parameter < LocalVariable
+      attr_reader :decl
+
+      attr_reader :asgn_code
+
+      def initialize decl: :arg, asgn_code: nil, **splat
+        super(splat)
+        @asgn_code = asgn_code
+        @decl = decl
+      end
+
+      def keyword?
+        [:kwarg, :kwoptarg].include?(decl)
+      end
+
+      def kwrestarg?
+        decl == :kwrestarg || (assignment && [:HASH, :hash].include?(assignment.type))
+      end
+
+      def restarg?
+        decl == :restarg
+      end
+
+      def rest?
+        decl == :restarg || decl == :kwrestarg
+      end
+
+      def full
+        case decl
+        when :optarg
+          "#{name} = #{asgn_code}"
+        when :kwarg
+          "#{name}:"
+        when :kwoptarg
+          "#{name}: #{asgn_code}"
+        when :restarg
+          "*#{name}"
+        when :kwrestarg
+          "**#{name}"
+        when :block
+          "&#{name}"
+        else
+          name
+        end
+      end
+
       def return_type
         if @return_type.nil?
-          @return_type = ComplexType.new
+          @return_type = ComplexType::UNDEFINED
           found = param_tag
           @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')
+            elsif decl == :kwrestarg
+              @return_type = ComplexType.try_parse('Hash')
+            elsif decl == :blockarg
+              @return_type = ComplexType.try_parse('Proc')
+            end
+          end
         end
         super
         @return_type
@@ -62,7 +116,7 @@ module Solargraph
       # @return [ComplexType]
       def typify_block_param api_map
         if closure.is_a?(Pin::Block) && closure.receiver
-          chain = Source::NodeChainer.chain(closure.receiver, filename)
+          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)

data/lib/solargraph/pin/reference.rb

@@ -6,6 +6,7 @@ module Solargraph
       autoload :Require,    'solargraph/pin/reference/require'
       autoload :Superclass, 'solargraph/pin/reference/superclass'
       autoload :Include,    'solargraph/pin/reference/include'
+      autoload :Prepend,    'solargraph/pin/reference/prepend'
       autoload :Extend,     'solargraph/pin/reference/extend'
       autoload :Override,   'solargraph/pin/reference/override'
     end

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

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

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

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Pin
+    class Reference
+      class Prepend < Reference
+      end
+    end
+  end
+end

data/lib/solargraph/pin/yard_pin/constant.rb

@@ -7,17 +7,15 @@ module Solargraph
         include YardMixin
 
         def initialize code_object, closure = nil, spec = nil
-          @code_object = code_object
-          @spec = spec
           closure ||= Solargraph::Pin::Namespace.new(
             name: code_object.namespace.to_s,
             gates: [code_object.namespace.to_s]
           )
           super(
-            location: location,
+            location: object_location(code_object, spec),
             closure: closure,
             name: code_object.name.to_s,
-            comments: nil,
+            comments: code_object.docstring ? code_object.docstring.all.to_s : '',
             visibility: code_object.visibility
           )
         end

data/lib/solargraph/pin/yard_pin/method.rb

@@ -7,41 +7,57 @@ module Solargraph
         include YardMixin
 
         def initialize code_object, name = nil, scope = nil, visibility = nil, closure = nil, spec = nil
-          @code_object = code_object
-          @spec = spec
           closure ||= Solargraph::Pin::Namespace.new(
             name: code_object.namespace.to_s,
             gates: [code_object.namespace.to_s]
           )
           super(
-            location: location,
+            location: object_location(code_object, spec),
             closure: closure,
             name: name || code_object.name.to_s,
-            comments: nil,
+            comments: code_object.docstring ? code_object.docstring.all.to_s : '',
             scope: scope || code_object.scope,
             visibility: visibility || code_object.visibility,
-            args: nil
+            parameters: get_parameters(code_object),
+            explicit: code_object.is_explicit?
           )
         end
 
-        def parameters
-          @parameters ||= get_parameters(code_object)
-        end
-
         private
 
         def get_parameters code_object
           return [] unless code_object.is_a?(YARD::CodeObjects::MethodObject)
-          args = []
-          code_object.parameters.each do |a|
-            p = a[0]
-            unless a[1].nil?
-              p += ' =' unless p.end_with?(':')
-              p += " #{a[1]}"
-            end
-            args.push p
+          code_object.parameters.map do |a|
+            Solargraph::Pin::Parameter.new(
+              location: location,
+              closure: self,
+              comments: comments,
+              name: arg_name(a),
+              presence: nil,
+              decl: arg_type(a),
+              asgn_code: a[1]
+            )
+          end
+        end
+
+        def arg_name a
+          a[0].match(/[A-Za-z0-9_]*/)[0]
+        end
+
+        def arg_type a
+          if a[0].start_with?('**')
+            :kwrestarg
+          elsif a[0].start_with?('*')
+            :restarg
+          elsif a[0].start_with?('&')
+            :blockarg
+          elsif a[1]
+            :optarg
+          elsif a[0].end_with?(':')
+            a[1] ? :kwarg : :kwoptarg
+          else
+            :arg
           end
-          args
         end
       end
     end