solargraph 0.38.6 → 0.39.0

data/lib/solargraph/language_server/message/text_document/formatting.rb

@@ -36,17 +36,22 @@ module Solargraph
           # @param result [String]
           # @return [void]
           def format original, result
-            if original.end_with?("\n")
-              ending = {
-                line: original.lines.length,
-                character: 0
-              }
-            else
-              ending = {
-                line: original.lines.length - 1,
-                character: original.lines.last.length
-              }
-            end
+            ending = if original.end_with?("\n")
+                       {
+                         line: original.lines.length,
+                         character: 0
+                       }
+                     elsif original.lines.empty?
+                       {
+                         line: 0,
+                         character: 0
+                       }
+                     else
+                       {
+                         line: original.lines.length - 1,
+                         character: original.lines.last.length
+                       }
+                     end
             set_result(
               [
                 {

data/lib/solargraph/language_server/transport/data_reader.rb

@@ -39,6 +39,7 @@ module Solargraph
 
         private
 
+        # @return [void]
         def prepare_to_parse_message
           @in_header = false
           @buffer.each_line do |line|
@@ -51,6 +52,7 @@ module Solargraph
           @buffer.clear
         end
 
+        # @return [void]
         def parse_message_from_buffer
           begin
             msg = JSON.parse(@buffer)

data/lib/solargraph/library.rb

@@ -224,10 +224,10 @@ module Solargraph
       result.uniq
     end
 
-    # Get the pin at the specified location or nil if the pin does not exist.
+    # Get the pins at the specified location or nil if the pin does not exist.
     #
     # @param location [Location]
-    # @return [Solargraph::Pin::Base]
+    # @return [Array<Solargraph::Pin::Base>]
     def locate_pins location
       api_map.locate_pins(location).map { |pin| pin.realize(api_map) }
     end
@@ -369,7 +369,7 @@ module Solargraph
     # @param source [Source]
     # @return [Boolean] True if the source was merged into the workspace.
     def merge source
-      result = nil
+      result = false
       mutex.synchronize do
         result = workspace.merge(source)
         @synchronized = !result if synchronized?

data/lib/solargraph/parser.rb

@@ -0,0 +1,26 @@
+module Solargraph
+  module Parser
+    autoload :CommentRipper, 'solargraph/parser/comment_ripper'
+    autoload :Legacy, 'solargraph/parser/legacy'
+    autoload :Rubyvm, 'solargraph/parser/rubyvm'
+    autoload :Region, 'solargraph/parser/region'
+    autoload :NodeProcessor, 'solargraph/parser/node_processor'
+    autoload :Snippet, 'solargraph/parser/snippet'
+
+    class SyntaxError < StandardError
+    end
+
+    # True if the parser can use RubyVM.
+    #
+    def self.rubyvm?
+      !!defined?(RubyVM::AbstractSyntaxTree)
+      # false
+    end
+
+    selected = rubyvm? ? Rubyvm : Legacy
+    # include selected
+    extend selected::ClassMethods
+
+    NodeMethods = (rubyvm? ? Rubyvm::NodeMethods : Legacy::NodeMethods)
+  end
+end

data/lib/solargraph/parser/comment_ripper.rb

@@ -0,0 +1,52 @@
+require 'ripper'
+
+module Solargraph
+  module Parser
+    class CommentRipper < Ripper::SexpBuilder
+      def initialize src, filename = '(ripper)', lineno = 0
+        super
+        @buffer = src
+        @buffer_lines = @buffer.lines
+      end
+
+      def on_comment *args
+        result = super
+        if @buffer_lines[result[2][0]][0..result[2][1]].strip =~ /^#/
+          chomped = result[1].chomp
+          if result[2][0] == 0 && chomped.encode('UTF-8', 'binary', invalid: :replace, undef: :replace, replace: '').match(/^#\s*frozen_string_literal:/)
+            chomped = '#'
+          end
+          @comments[result[2][0]] = Snippet.new(Range.from_to(result[2][0], result[2][1], result[2][0], result[2][1] + chomped.length), chomped)
+        end
+        result
+      end
+
+      def on_embdoc_beg *args
+        result = super
+        chomped = result[1].chomp
+        @comments[result[2][0]] = Snippet.new(Range.from_to(result[2][0], result[2][1], result[2][0], result[2][1] + chomped.length), chomped)
+        result
+      end
+
+      def on_embdoc *args
+        result = super
+        chomped = result[1].chomp
+        @comments[result[2][0]] = Snippet.new(Range.from_to(result[2][0], result[2][1], result[2][0], result[2][1] + chomped.length), chomped)
+        result
+      end
+
+      def on_embdoc_end *args
+        result = super
+        chomped = result[1].chomp
+        @comments[result[2][0]] = Snippet.new(Range.from_to(result[2][0], result[2][1], result[2][0], result[2][1] + chomped.length), chomped)
+        result
+      end
+
+      def parse
+        @comments = {}
+        super
+        @comments
+      end
+    end
+  end
+end

data/lib/solargraph/parser/legacy.rb

@@ -0,0 +1,12 @@
+module Solargraph
+  module Parser
+    module Legacy
+      autoload :FlawedBuilder, 'solargraph/parser/legacy/flawed_builder'
+      autoload :ClassMethods, 'solargraph/parser/legacy/class_methods'
+      autoload :NodeMethods, 'solargraph/parser/legacy/node_methods'
+      autoload :NodeChainer, 'solargraph/parser/legacy/node_chainer'
+    end
+  end
+end
+
+require 'solargraph/parser/legacy/node_processors'

data/lib/solargraph/parser/legacy/class_methods.rb

@@ -0,0 +1,105 @@
+require 'parser/current'
+
+module Solargraph
+  module Parser
+    module Legacy
+      module ClassMethods
+        # @param code [String]
+        # @param filename [String]
+        # @return [Array(Parser::AST::Node, Array<Parser::Source::Comment>)]
+        def parse_with_comments code, filename = nil
+          buffer = ::Parser::Source::Buffer.new(filename, 0)
+          buffer.source = code
+          node = parser.parse(buffer)
+          comments = CommentRipper.new(code, filename, 0).parse
+          [node, comments]
+        rescue ::Parser::SyntaxError => e
+          raise Parser::SyntaxError, e.message
+        end
+
+        # @param code [String]
+        # @param filename [String, nil]
+        # @param line [Integer]
+        # @return [Parser::AST::Node]
+        def parse code, filename = nil, line = 0
+          buffer = ::Parser::Source::Buffer.new(filename, line)
+          buffer.source = code
+          parser.parse(buffer)
+        rescue ::Parser::SyntaxError => e
+          raise Parser::SyntaxError, e.message
+        end
+
+        # @return [Parser::Base]
+        def parser
+          # @todo Consider setting an instance variable. We might not need to
+          #   recreate the parser every time we use it.
+          parser = ::Parser::CurrentRuby.new(FlawedBuilder.new)
+          parser.diagnostics.all_errors_are_fatal = true
+          parser.diagnostics.ignore_warnings      = true
+          parser
+        end
+
+        def map source
+          NodeProcessor.process(source.node, Region.new(source: source))
+        end
+
+        def returns_from node
+          NodeMethods.returns_from(node)
+        end
+
+        def references source, name
+          inner_node_references(name, source.node).map do |n|
+            offset = Position.to_offset(source.code, NodeMethods.get_node_start_position(n))
+            soff = source.code.index(name, offset)
+            eoff = soff + name.length
+            Location.new(
+              source.filename,
+              Range.new(
+                Position.from_offset(source.code, soff),
+                Position.from_offset(source.code, eoff)
+              )
+            )
+          end
+        end
+
+        # @param name [String]
+        # @param top [AST::Node]
+        # @return [Array<AST::Node>]
+        def inner_node_references name, top
+          result = []
+          if top.is_a?(AST::Node) && top.to_s.include?(":#{name}")
+            result.push top if top.children.any? { |c| c.to_s == name }
+            top.children.each { |c| result.concat inner_node_references(name, c) }
+          end
+          result
+        end
+
+        def chain *args
+          NodeChainer.chain *args
+        end
+
+        def process_node *args
+          Solargraph::Parser::NodeProcessor.process *args
+        end
+
+        def infer_literal_node_type node
+          NodeMethods.infer_literal_node_type node
+        end
+
+        def version
+          parser.version
+        end
+
+        def is_ast_node? node
+          node.is_a?(::Parser::AST::Node)
+        end
+
+        def node_range node
+          st = Position.new(node.loc.line, node.loc.column)
+          en = Position.new(node.loc.last_line, node.loc.last_column)
+          Range.new(st, en)
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/parser/legacy/flawed_builder.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Parser
+    module Legacy
+      # A custom builder for source parsers that ignores character encoding
+      # issues in literal strings.
+      #
+      class FlawedBuilder < ::Parser::Builders::Default
+        def string_value(token)
+          value(token)
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/parser/legacy/node_chainer.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Parser
+    module Legacy
+      # A factory for generating chains from nodes.
+      #
+      class NodeChainer
+        include NodeMethods
+        Chain = Source::Chain
+
+        # @param node [Parser::AST::Node]
+        # @param filename [String]
+        def initialize node, filename = nil, in_block = false
+          @node = node
+          @filename = filename
+          @in_block = in_block
+        end
+
+        # @return [Source::Chain]
+        def chain
+          links = generate_links(@node)
+          Chain.new(links, @node, (Parser.is_ast_node?(@node) && @node.type == :splat))
+        end
+
+        class << self
+          # @param node [Parser::AST::Node]
+          # @param filename [String]
+          # @return [Source::Chain]
+          def chain node, filename = nil, in_block = false
+            NodeChainer.new(node, filename, in_block).chain
+          end
+
+          # @param code [String]
+          # @return [Source::Chain]
+          def load_string(code)
+            node = Parser.parse(code.sub(/\.$/, ''))
+            chain = NodeChainer.new(node).chain
+            chain.links.push(Chain::Link.new) if code.end_with?('.')
+            chain
+          end
+        end
+
+        private
+
+        # @param n [Parser::AST::Node]
+        # @return [Array<Chain::Link>]
+        def generate_links n
+          return [] unless n.is_a?(::Parser::AST::Node)
+          return generate_links(n.children[0]) if n.type == :begin
+          return generate_links(n.children[0]) if n.type == :splat
+          result = []
+          if n.type == :block
+            @in_block = true
+            result.concat generate_links(n.children[0])
+            @in_block = false
+          elsif n.type == :send
+            if n.children[0].is_a?(::Parser::AST::Node)
+              result.concat generate_links(n.children[0])
+              args = []
+              n.children[2..-1].each do |c|
+                args.push NodeChainer.chain(c)
+              end
+              result.push Chain::Call.new(n.children[1].to_s, args, @in_block || block_passed?(n))
+            elsif n.children[0].nil?
+              args = []
+              n.children[2..-1].each do |c|
+                args.push NodeChainer.chain(c)
+              end
+              result.push Chain::Call.new(n.children[1].to_s, args, @in_block || block_passed?(n))
+            else
+              raise "No idea what to do with #{n}"
+            end
+          elsif n.type == :self
+            result.push Chain::Head.new('self')
+          elsif [:super, :zsuper].include?(n.type)
+            result.push Chain::Head.new('super')
+          elsif n.type == :const
+            const = unpack_name(n)
+            result.push Chain::Constant.new(const)
+          elsif [:lvar, :lvasgn].include?(n.type)
+            result.push Chain::Call.new(n.children[0].to_s)
+          elsif [:ivar, :ivasgn].include?(n.type)
+            result.push Chain::InstanceVariable.new(n.children[0].to_s)
+          elsif [:cvar, :cvasgn].include?(n.type)
+            result.push Chain::ClassVariable.new(n.children[0].to_s)
+          elsif [:gvar, :gvasgn].include?(n.type)
+            result.push Chain::GlobalVariable.new(n.children[0].to_s)
+          elsif n.type == :or_asgn
+            result.concat generate_links n.children[1]
+          elsif [:class, :module, :def, :defs].include?(n.type)
+            # @todo Undefined or what?
+            result.push Chain::UNDEFINED_CALL
+          elsif n.type == :and
+            result.concat generate_links(n.children.last)
+          elsif n.type == :or
+            result.push Chain::Or.new([NodeChainer.chain(n.children[0], @filename), NodeChainer.chain(n.children[1], @filename)])
+          elsif [:begin, :kwbegin].include?(n.type)
+            result.concat generate_links(n.children[0])
+          elsif n.type == :block_pass
+            result.push Chain::BlockVariable.new("&#{n.children[0].children[0].to_s}")
+          else
+            lit = infer_literal_node_type(n)
+            result.push (lit ? Chain::Literal.new(lit) : Chain::Link.new)
+          end
+          result
+        end
+
+        def block_passed? node
+          node.children.last.is_a?(::Parser::AST::Node) && node.children.last.type == :block_pass
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,289 @@
+# frozen_string_literal: true
+
+require 'parser'
+
+module Solargraph
+  module Parser
+    module Legacy
+      module NodeMethods
+        module_function
+
+        # @param node [Parser::AST::Node]
+        # @return [String]
+        def unpack_name(node)
+          pack_name(node).join("::")
+        end
+
+        # @param node [Parser::AST::Node]
+        # @return [Array<String>]
+        def pack_name(node)
+          parts = []
+          if node.is_a?(AST::Node)
+            node.children.each { |n|
+              if n.is_a?(AST::Node)
+                if n.type == :cbase
+                  parts = [''] + pack_name(n)
+                else
+                  parts += pack_name(n)
+                end
+              else
+                parts.push n unless n.nil?
+              end
+            }
+          end
+          parts
+        end
+
+        # @param node [Parser::AST::Node]
+        # @return [String, nil]
+        def infer_literal_node_type node
+          return nil unless node.is_a?(AST::Node)
+          if node.type == :str || node.type == :dstr
+            return '::String'
+          elsif node.type == :array
+            return '::Array'
+          elsif node.type == :hash
+            return '::Hash'
+          elsif node.type == :int
+            return '::Integer'
+          elsif node.type == :float
+            return '::Float'
+          elsif node.type == :sym
+            return '::Symbol'
+          elsif node.type == :regexp
+            return '::Regexp'
+          elsif node.type == :irange
+            return '::Range'
+          elsif node.type == :true || node.type == :false
+            return '::Boolean'
+            # @todo Support `nil` keyword in types
+          # elsif node.type == :nil
+          #   return 'NilClass'
+          end
+          nil
+        end
+
+        # @param node [Parser::AST::Node]
+        # @return [Position]
+        def get_node_start_position(node)
+          Position.new(node.loc.line, node.loc.column)
+        end
+
+        # @param node [Parser::AST::Node]
+        # @return [Position]
+        def get_node_end_position(node)
+          Position.new(node.loc.last_line, node.loc.last_column)
+        end
+
+        def drill_signature node, signature
+          return signature unless node.is_a?(AST::Node)
+          if node.type == :const or node.type == :cbase
+            unless node.children[0].nil?
+              signature += drill_signature(node.children[0], signature)
+            end
+            signature += '::' unless signature.empty?
+            signature += node.children[1].to_s
+          elsif node.type == :lvar or node.type == :ivar or node.type == :cvar
+            signature += '.' unless signature.empty?
+            signature += node.children[0].to_s
+          elsif node.type == :send
+            unless node.children[0].nil?
+              signature += drill_signature(node.children[0], signature)
+            end
+            signature += '.' unless signature.empty?
+            signature += node.children[1].to_s
+          end
+          signature
+        end
+
+        def convert_hash node
+          return {} unless Parser.is_ast_node?(node) && node.type == :hash
+          result = {}
+          node.children.each do |pair|
+            result[pair.children[0].children[0]] = Solargraph::Parser.chain(pair.children[1])
+          end
+          result
+        end
+
+        NIL_NODE = ::Parser::AST::Node.new(:nil)
+
+        def const_nodes_from node
+          return [] unless Parser.is_ast_node?(node)
+          result = []
+          if node.type == :const
+            result.push node
+          else
+            node.children.each { |child| result.concat const_nodes_from(child) }
+          end
+          result
+        end
+
+        # @todo Temporarily here for testing. Move to Solargraph::Parser.
+        def call_nodes_from node
+          return [] unless node.is_a?(::Parser::AST::Node)
+          result = []
+          if node.type == :block
+            result.push node
+            node.children[0].children[2..-1].each { |child| result.concat call_nodes_from(child) }
+            node.children[1..-1].each { |child| result.concat call_nodes_from(child) }
+          elsif node.type == :send
+            result.push node
+            node.children[2..-1].each { |child| result.concat call_nodes_from(child) }
+          else
+            node.children.each { |child| result.concat call_nodes_from(child) }
+          end
+          result
+        end
+
+        # Find all the nodes within the provided node that potentially return a
+        # value.
+        #
+        # The node parameter typically represents a method's logic, e.g., the
+        # second child (after the :args node) of a :def node. A simple one-line
+        # method would typically return itself, while a node with conditions
+        # would return the resulting node from each conditional branch. Nodes
+        # that follow a :return node are assumed to be unreachable. Nil values
+        # are converted to nil node types.
+        #
+        # @param node [Parser::AST::Node]
+        # @return [Array<Parser::AST::Node>]
+        def returns_from node
+          DeepInference.get_return_nodes(node).map { |n| n || NIL_NODE }
+        end
+
+        # @param cursor [Solargraph::Source::Cursor]
+        def find_recipient_node cursor
+          source = cursor.source
+          position = cursor.position
+          offset = cursor.offset
+          tree = if source.synchronized?
+            match = source.code[0..offset-1].match(/,\s*\z/)
+            if match
+              source.tree_at(position.line, position.column - match[0].length)
+            else
+              source.tree_at(position.line, position.column)
+            end
+          else
+            source.tree_at(position.line, position.column - 1)
+          end
+          prev = nil
+          tree.each do |node|
+            if node.type == :send
+              args = node.children[2..-1]
+              if !args.empty?
+                return node if prev && args.include?(prev)
+              else
+                if source.synchronized?
+                  return node if source.code[0..offset-1] =~ /\(\s*\z/ && source.code[offset..-1] =~ /^\s*\)/
+                else
+                  return node if source.code[0..offset-1] =~ /\([^\(]*\z/
+                end
+              end
+            end
+            prev = node
+          end
+          nil
+        end
+
+        module DeepInference
+          class << self
+            CONDITIONAL = [:if, :unless]
+            REDUCEABLE = [:begin, :kwbegin]
+            SKIPPABLE = [:def, :defs, :class, :sclass, :module]
+
+            # @param node [Parser::AST::Node]
+            # @return [Array<Parser::AST::Node>]
+            def get_return_nodes node
+              return [] unless node.is_a?(::Parser::AST::Node)
+              result = []
+              if REDUCEABLE.include?(node.type)
+                result.concat get_return_nodes_from_children(node)
+              elsif CONDITIONAL.include?(node.type)
+                result.concat reduce_to_value_nodes(node.children[1..-1])
+                # result.push NIL_NODE unless node.children[2]
+              elsif node.type == :or
+                result.concat reduce_to_value_nodes(node.children)
+              elsif node.type == :return
+                result.concat reduce_to_value_nodes([node.children[0]])
+              elsif node.type == :block
+                result.push node
+                result.concat get_return_nodes_only(node.children[2])
+              elsif node.type == :case
+                node.children[1..-1].each do |cc|
+                  result.concat reduce_to_value_nodes(cc.children[1..-2])
+                  result.concat reduce_to_value_nodes([cc.children.last])
+                end
+              else
+                result.push node
+              end
+              result
+            end
+
+            private
+
+            def get_return_nodes_from_children parent
+              result = []
+              nodes = parent.children.select{|n| n.is_a?(AST::Node)}
+              nodes.each_with_index do |node, idx|
+                if node.type == :block
+                  result.concat get_return_nodes_only(node.children[2])
+                elsif SKIPPABLE.include?(node.type)
+                  next
+                elsif node.type == :return
+                  result.concat reduce_to_value_nodes([node.children[0]])
+                  # Return the result here because the rest of the code is
+                  # unreachable
+                  return result
+                else
+                  result.concat get_return_nodes_only(node)
+                end
+                result.concat reduce_to_value_nodes([nodes.last]) if idx == nodes.length - 1
+              end
+              result
+            end
+
+            def get_return_nodes_only parent
+              return [] unless parent.is_a?(::Parser::AST::Node)
+              result = []
+              nodes = parent.children.select{|n| n.is_a?(::Parser::AST::Node)}
+              nodes.each do |node|
+                next if SKIPPABLE.include?(node.type)
+                if node.type == :return
+                  result.concat reduce_to_value_nodes([node.children[0]])
+                  # Return the result here because the rest of the code is
+                  # unreachable
+                  return result
+                else
+                  result.concat get_return_nodes_only(node)
+                end
+              end
+              result
+            end
+
+            def reduce_to_value_nodes nodes
+              result = []
+              nodes.each do |node|
+                if !node.is_a?(::Parser::AST::Node)
+                  result.push nil
+                elsif REDUCEABLE.include?(node.type)
+                  result.concat get_return_nodes_from_children(node)
+                elsif CONDITIONAL.include?(node.type)
+                  result.concat reduce_to_value_nodes(node.children[1..-1])
+                elsif node.type == :return
+                  result.concat reduce_to_value_nodes([node.children[0]])
+                elsif node.type == :or
+                  result.concat reduce_to_value_nodes(node.children)
+                elsif node.type == :block
+                  result.concat get_return_nodes_only(node.children[2])
+                else
+                  result.push node
+                end
+              end
+              result
+            end
+          end
+        end
+      end
+    end
+  end
+end