solargraph 0.39.16 → 0.40.3

data/lib/solargraph/parser/node_processor/base.rb

@@ -27,6 +27,7 @@ module Solargraph
           @region = region
           @pins = pins
           @locals = locals
+          @processed_children = false
         end
 
         # Subclasses should override this method to generate new pins.
@@ -41,6 +42,8 @@ module Solargraph
         # @param subregion [Region]
         # @return [void]
         def process_children subregion = region
+          return if @processed_children
+          @processed_children = true
           node.children.each do |child|
             next unless Parser.is_ast_node?(child)
             NodeProcessor.process(child, subregion, pins, locals)

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

@@ -90,7 +90,9 @@ module Solargraph
         end
 
         def convert_hash node
-          return {} unless node?(node) && node.type == :HASH && node?(node.children[0])
+          return {} unless node?(node) && node.type == :HASH
+          return convert_hash(node.children[0].children[1]) if splatted_hash?(node)
+          return {} unless node?(node.children[0])
           result = {}
           index = 0
           until index > node.children[0].children.length - 2
@@ -103,6 +105,21 @@ module Solargraph
           result
         end
 
+        def splatted_hash? node
+          splatted_node?(node) && node.children[0].children[1].type == :HASH
+        end
+
+        def splatted_node? node
+          node?(node.children[0]) &&
+            [:ARRAY, :LIST].include?(node.children[0].type) &&
+            node.children[0].children[0].nil? &&
+            node?(node.children[0].children[1])
+        end
+
+        def splatted_call? node
+          splatted_node?(node) && node.children[0].children[1].type != :HASH
+        end
+
         def node? node
           node.is_a?(RubyVM::AbstractSyntaxTree::Node)
         end

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

@@ -6,7 +6,7 @@ module Solargraph
       module NodeProcessors
         class ArgsNode < Parser::NodeProcessor::Base
           def process
-            if region.closure.is_a?(Pin::BaseMethod) || region.closure.is_a?(Pin::Block)
+            if region.closure.is_a?(Pin::Method) || region.closure.is_a?(Pin::Block)
               if region.lvars[0].nil?
                 node.children[0].times do |i|
                   locals.push Solargraph::Pin::Parameter.new(

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

@@ -19,7 +19,7 @@ module Solargraph
             if region.visibility == :module_function
               rng = Range.from_node(node)
               named_path = named_path_pin(rng.start)
-              if named_path.is_a?(Pin::BaseMethod)
+              if named_path.is_a?(Pin::Method)
                 pins.push Solargraph::Pin::InstanceVariable.new(
                   location: loc,
                   closure: Pin::Namespace.new(type: :module, closure: region.closure.closure, name: region.closure.name),

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

@@ -9,21 +9,7 @@ module Solargraph
 
           def process
             if [:private, :public, :protected].include?(node.children[0])
-              if node.type == :FCALL && Parser.is_ast_node?(node.children.last)
-                node.children.last.children[0..-2].each do |child|
-                  # next unless child.is_a?(AST::Node) && (child.type == :sym || child.type == :str)
-                  next unless child.type == :LIT || child.type == :STR
-                  name = child.children[0].to_s
-                  matches = pins.select{ |pin| pin.is_a?(Pin::BaseMethod) && pin.name == name && pin.namespace == region.closure.full_context.namespace && pin.context.scope == (region.scope || :instance)}
-                  matches.each do |pin|
-                    # @todo Smelly instance variable access
-                    pin.instance_variable_set(:@visibility, node.children[0])
-                  end
-                end
-              else
-                # @todo Smelly instance variable access
-                region.instance_variable_set(:@visibility, node.children[0])
-              end
+              process_visibility
             elsif node.children[0] == :module_function
               process_module_function
             elsif node.children[0] == :require
@@ -33,8 +19,7 @@ module Solargraph
             elsif node.children[0] == :alias_method
               process_alias_method
             elsif node.children[0] == :private_class_method
-              # Processing a private class can potentially handle children on its own
-              return if process_private_class_method
+              process_private_class_method
             elsif [:attr_reader, :attr_writer, :attr_accessor].include?(node.children[0])
               process_attribute
             elsif node.children[0] == :include
@@ -53,6 +38,28 @@ module Solargraph
 
           private
 
+          # @return [void]
+          def process_visibility
+            if node.type == :FCALL && Parser.is_ast_node?(node.children.last)
+              node.children.last.children[0..-2].each do |child|
+                # next unless child.is_a?(AST::Node) && (child.type == :sym || child.type == :str)
+                if child.type == :LIT || child.type == :STR
+                  name = child.children[0].to_s
+                  matches = pins.select{ |pin| pin.is_a?(Pin::Method) && pin.name == name && pin.namespace == region.closure.full_context.namespace && pin.context.scope == (region.scope || :instance)}
+                  matches.each do |pin|
+                    # @todo Smelly instance variable access
+                    pin.instance_variable_set(:@visibility, node.children[0])
+                  end
+                else
+                  process_children region.update(visibility: node.children[0])
+                end
+              end
+            else
+              # @todo Smelly instance variable access
+              region.instance_variable_set(:@visibility, node.children[0])
+            end
+          end
+
           # @return [void]
           def process_attribute
             return unless Parser.is_ast_node?(node.children[1])
@@ -62,26 +69,30 @@ module Solargraph
               clos = region.closure
               cmnt = comments_for(node)
               if node.children[0] == :attr_reader || node.children[0] == :attr_accessor
-                pins.push Solargraph::Pin::Attribute.new(
+                pins.push Solargraph::Pin::Method.new(
                   location: loc,
                   closure: clos,
                   name: a.children[0].to_s,
                   comments: cmnt,
-                  access: :reader,
                   scope: region.scope || :instance,
-                  visibility: region.visibility
+                  visibility: region.visibility,
+                  attribute: true
                 )
               end
               if node.children[0] == :attr_writer || node.children[0] == :attr_accessor
-                pins.push Solargraph::Pin::Attribute.new(
+                pins.push Solargraph::Pin::Method.new(
                   location: loc,
                   closure: clos,
                   name: "#{a.children[0]}=",
                   comments: cmnt,
-                  access: :writer,
                   scope: region.scope || :instance,
-                  visibility: region.visibility
+                  visibility: region.visibility,
+                  attribute: true
                 )
+                pins.last.parameters.push Pin::Parameter.new(name: 'value', decl: :arg, closure: pins.last)
+                if pins.last.return_type.defined?
+                  pins.last.docstring.add_tag YARD::Tags::Tag.new(:param, '', pins.last.return_type.to_s.split(', '), 'value')
+                end
               end
             end
           end
@@ -166,7 +177,7 @@ module Solargraph
               node.children.last.children[0..-2].each do |x|
                 next unless [:LIT, :STR].include?(x.type)
                 cn = x.children[0].to_s
-                ref = pins.select{|p| [Solargraph::Pin::Method, Solargraph::Pin::Attribute].include?(p.class) && p.namespace == region.closure.full_context.namespace && p.name == cn}.first
+                ref = pins.select { |p| p.is_a?(Pin::Method) && p.namespace == region.closure.full_context.namespace && p.name == cn }.first
                 unless ref.nil?
                   pins.delete ref
                   mm = Solargraph::Pin::Method.new(
@@ -215,6 +226,7 @@ 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|
               if [:LIT, :STR].include?(child.type)
                 cn = child.children[0].to_s
@@ -242,20 +254,18 @@ module Solargraph
             )
           end
 
-          # @return [Boolean]
+          # @return [void]
           def process_private_class_method
             return false unless Parser.is_ast_node?(node.children.last)
             if node.children.last.children.first.type == :DEFN
               process_children region.update(scope: :class, visibility: :private)
-              true
             else
               node.children.last.children[0..-2].each do |child|
                 if child.type == :LIT && child.children.first.is_a?(::Symbol)
                   sym_name = child.children.first.to_s
-                  ref = pins.select{|p| [Solargraph::Pin::Method, Solargraph::Pin::Attribute].include?(p.class) && p.namespace == region.closure.full_context.namespace && p.name == sym_name}.first
+                  ref = pins.select { |p| p.is_a?(Pin::Method) && p.namespace == region.closure.full_context.namespace && p.name == sym_name }.first
                   # HACK: Smelly instance variable access
                   ref.instance_variable_set(:@visibility, :private) unless ref.nil?
-                  false
                 end
               end
             end

data/lib/solargraph/pin.rb

@@ -9,10 +9,8 @@ module Solargraph
     autoload :Common,           'solargraph/pin/common'
     autoload :Conversions,      'solargraph/pin/conversions'
     autoload :Base,             'solargraph/pin/base'
-    autoload :BaseMethod,       'solargraph/pin/base_method'
     autoload :Method,           'solargraph/pin/method'
     autoload :MethodAlias,      'solargraph/pin/method_alias'
-    autoload :Attribute,        'solargraph/pin/attribute'
     autoload :BaseVariable,     'solargraph/pin/base_variable'
     autoload :InstanceVariable, 'solargraph/pin/instance_variable'
     autoload :ClassVariable,    'solargraph/pin/class_variable'
@@ -30,7 +28,6 @@ module Solargraph
     autoload :Localized,        'solargraph/pin/localized'
     autoload :ProxyType,        'solargraph/pin/proxy_type'
     autoload :DuckMethod,       'solargraph/pin/duck_method'
-    autoload :YardPin,          'solargraph/pin/yard_pin'
     autoload :Singleton,        'solargraph/pin/singleton'
     autoload :KeywordParam,     'solargraph/pin/keyword_param'
 

data/lib/solargraph/pin/common.rb

@@ -54,7 +54,7 @@ module Solargraph
         until here.nil?
           if here.is_a?(Pin::Namespace)
             return here.return_type
-          elsif here.is_a?(Pin::BaseMethod)
+          elsif here.is_a?(Pin::Method)
             if here.scope == :instance
               return ComplexType.try_parse(here.context.namespace)
             else

data/lib/solargraph/pin/conversions.rb

@@ -47,7 +47,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.map(&:full).join(', ')}) " unless !is_a?(Pin::BaseMethod) || parameters.empty?
+        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/documenting.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
-require 'maruku'
+require 'kramdown'
+require 'kramdown-parser-gfm'
 require 'yard'
 require 'reverse_markdown'
 require 'solargraph/converters/dl'
@@ -8,9 +9,6 @@ require 'solargraph/converters/dt'
 require 'solargraph/converters/dd'
 require 'solargraph/converters/misc'
 
-# HACK: Setting :html_parser through `Maruku.new` does not work
-MaRuKu::Globals[:html_parser] = 'nokogiri'
-
 module Solargraph
   module Pin
     # A module to add the Pin::Base#documentation method.
@@ -41,11 +39,7 @@ module Solargraph
 
         def to_s
           return "\n```ruby\n#{@plaintext}#{@plaintext.end_with?("\n") ? '' : "\n"}```\n\n" if code?
-          ReverseMarkdown.convert unescape_brackets(Maruku.new(escape_brackets(@plaintext), on_error: :raise).to_html)
-        rescue MaRuKu::Exception
-          # Maruku exceptions usually indicate that the documentation is in
-          # RDoc syntax.
-          ReverseMarkdown.convert YARD::Templates::Helpers::Markup::RDocMarkup.new(@plaintext).to_html
+          ReverseMarkdown.convert unescape_brackets(Kramdown::Document.new(escape_brackets(@plaintext), input: 'GFM').to_html)
         end
 
         private

data/lib/solargraph/pin/method.rb

@@ -2,18 +2,29 @@
 
 module Solargraph
   module Pin
-    class Method < BaseMethod
+    # The base class for method and attribute pins.
+    #
+    class Method < Closure
       include Solargraph::Parser::NodeMethods
 
       # @return [Array<Pin::Parameter>]
       attr_reader :parameters
 
-      # @param args [Array<String>]
-      # @param node [Parser::AST::Node, nil]
-      def initialize parameters: [], node: nil, **splat
+      # @return [::Symbol] :public, :private, or :protected
+      attr_reader :visibility
+
+      # @return [Parser::AST::Node]
+      attr_reader :node
+
+      # @param visibility [::Symbol] :public, :protected, or :private
+      # @param explicit [Boolean]
+      def initialize visibility: :public, explicit: true, parameters: [], node: nil, attribute: false, **splat
         super(**splat)
+        @visibility = visibility
+        @explicit = explicit
         @parameters = parameters
         @node = node
+        @attribute = attribute
       end
 
       # @return [Array<String>]
@@ -22,11 +33,70 @@ module Solargraph
       end
 
       def completion_item_kind
-        Solargraph::LanguageServer::CompletionItemKinds::METHOD
+        attribute? ? Solargraph::LanguageServer::CompletionItemKinds::PROPERTY : Solargraph::LanguageServer::CompletionItemKinds::METHOD
       end
 
       def symbol_kind
-        LanguageServer::SymbolKinds::METHOD
+        attribute? ? Solargraph::LanguageServer::SymbolKinds::PROPERTY : LanguageServer::SymbolKinds::METHOD
+      end
+
+      def return_type
+        @return_type ||= generate_complex_type
+      end
+
+      def path
+        @path ||= "#{namespace}#{(scope == :instance ? '#' : '.')}#{name}"
+      end
+
+      def typify api_map
+        decl = super
+        return decl unless decl.undefined?
+        type = see_reference(api_map) || typify_from_super(api_map)
+        return type.qualify(api_map, namespace) unless type.nil?
+        name.end_with?('?') ? ComplexType::BOOLEAN : ComplexType::UNDEFINED
+      end
+
+      def documentation
+        if @documentation.nil?
+          @documentation ||= super || ''
+          param_tags = docstring.tags(:param)
+          unless param_tags.nil? or param_tags.empty?
+            @documentation += "\n\n" unless @documentation.empty?
+            @documentation += "Params:\n"
+            lines = []
+            param_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
+          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
+
+      def attribute?
+        @attribute
       end
 
       def nearly? other
@@ -37,7 +107,7 @@ module Solargraph
       end
 
       def probe api_map
-        infer_from_return_nodes(api_map)
+        attribute? ? infer_from_iv(api_map) : infer_from_return_nodes(api_map)
       end
 
       def try_merge! pin
@@ -70,6 +140,57 @@ module Solargraph
 
       private
 
+      # @return [ComplexType]
+      def generate_complex_type
+        tags = docstring.tags(:return).map(&:types).flatten.reject(&:nil?)
+        return ComplexType::UNDEFINED if tags.empty?
+        ComplexType.try_parse *tags
+      end
+
+      # @param api_map [ApiMap]
+      # @return [ComplexType, nil]
+      def see_reference api_map
+        docstring.ref_tags.each do |ref|
+          next unless ref.tag_name == 'return' && ref.owner
+          result = resolve_reference(ref.owner.to_s, api_map)
+          return result unless result.nil?
+        end
+        match = comments.match(/^[ \t]*\(see (.*)\)/m)
+        return nil if match.nil?
+        resolve_reference match[1], api_map
+      end
+
+      # @param api_map [ApiMap]
+      # @return [ComplexType, nil]
+      def typify_from_super api_map
+        stack = api_map.get_method_stack(namespace, name, scope: scope).reject { |pin| pin.path == path }
+        return nil if stack.empty?
+        stack.each do |pin|
+          return pin.return_type unless pin.return_type.undefined?
+        end
+        nil
+      end
+
+      # @param ref [String]
+      # @param api_map [ApiMap]
+      # @return [ComplexType]
+      def resolve_reference ref, api_map
+        parts = ref.split(/[\.#]/)
+        if parts.first.empty? || parts.one?
+          path = "#{namespace}#{ref}"
+        else
+          fqns = api_map.qualify(parts.first, namespace)
+          return ComplexType::UNDEFINED if fqns.nil?
+          path = fqns + ref[parts.first.length] + parts.last
+        end
+        pins = api_map.get_path_pins(path)
+        pins.each do |pin|
+          type = pin.typify(api_map)
+          return type unless type.undefined?
+        end
+        nil
+      end
+
       # @return [Parser::AST::Node, nil]
       def method_body_node
         return nil if node.nil?
@@ -106,6 +227,19 @@ module Solargraph
         return ComplexType::UNDEFINED if result.empty?
         ComplexType.try_parse(*result.map(&:tag).uniq)
       end
+
+      def infer_from_iv api_map
+        types = []
+        varname = "@#{name.gsub(/=$/, '')}"
+        pins = api_map.get_instance_variable_pins(binder.namespace, binder.scope).select { |iv| iv.name == varname }
+        pins.each do |pin|
+          type = pin.typify(api_map)
+          type = pin.probe(api_map) if type.undefined?
+          types.push type if type.defined?
+        end
+        return ComplexType::UNDEFINED if types.empty?
+        ComplexType.try_parse(*types.map(&:tag).uniq)
+      end
     end
   end
 end