solargraph 0.38.6 → 0.39.0

data/lib/solargraph/{source_map → parser}/region.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
 module Solargraph
-  class SourceMap
-    # Data used by the NodeProcessor library to track context at various
-    # locations in a source.
+  module Parser
+    # Data used by the parser to track context at various locations in a
+    # source.
     #
     class Region
       # @return [Pin::Closure]
@@ -18,17 +18,21 @@ module Solargraph
       # @return [Solargraph::Source]
       attr_reader :source
 
+      # @return [Array<Symbol>]
+      attr_reader :lvars
+
       # @param source [Source]
       # @param namespace [String]
       # @param scope [Symbol]
       # @param visibility [Symbol]
       def initialize source: Solargraph::Source.load_string(''), closure: nil,
-                     scope: nil, visibility: :public
+                     scope: nil, visibility: :public, lvars: []
         @source = source
         # @closure = closure
         @closure = closure || Pin::Namespace.new(name: '', location: source.location)
         @scope = scope
         @visibility = visibility
+        @lvars = lvars
       end
 
       # @return [String]
@@ -42,12 +46,13 @@ module Solargraph
       # @param scope [Symbol, nil]
       # @param visibility [Symbol, nil]
       # @return [Region]
-      def update closure: nil, scope: nil, visibility: nil
+      def update closure: nil, scope: nil, visibility: nil, lvars: nil
         Region.new(
           source: source,
           closure: closure || self.closure,
           scope: scope || self.scope,
-          visibility: visibility || self.visibility
+          visibility: visibility || self.visibility,
+          lvars: lvars || self.lvars
         )
       end
 

data/lib/solargraph/parser/rubyvm.rb

@@ -0,0 +1,40 @@
+module Solargraph
+  module Parser
+    module Rubyvm
+      autoload :ClassMethods, 'solargraph/parser/rubyvm/class_methods'
+      autoload :NodeChainer,  'solargraph/parser/rubyvm/node_chainer'
+      autoload :NodeMethods,  'solargraph/parser/rubyvm/node_methods'
+    end
+  end
+end
+
+require 'solargraph/parser/rubyvm/node_processors'
+
+class RubyVM::AbstractSyntaxTree::Node
+  def to_sexp
+    sexp self
+  end
+
+  def == other
+    return false unless other.is_a?(self.class)
+    here = Solargraph::Range.from_node(self)
+    there = Solargraph::Range.from_node(other)
+    here == there && to_sexp == other.to_sexp
+  end
+
+  private
+
+  def sexp node, depth = 0
+    result = ''
+    if node.is_a?(RubyVM::AbstractSyntaxTree::Node)
+      result += "#{'  ' * depth}(:#{node.type}"
+      node.children.each do |child|
+        result += "\n" + sexp(child, depth + 1)
+      end
+      result += ")"
+    else
+      result += "#{'  ' * depth}#{node.inspect}"
+    end
+    result
+  end
+end

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

@@ -0,0 +1,146 @@
+require 'solargraph/parser/rubyvm/node_processors'
+
+module Solargraph
+  module Parser
+    module Rubyvm
+      module ClassMethods
+        # @param code [String]
+        # @param filename [String]
+        # @return [Array(Parser::AST::Node, Array<Parser::Source::Comment>)]
+        def parse_with_comments code, filename = nil
+          node = RubyVM::AbstractSyntaxTree.parse(code)
+          comments = CommentRipper.new(code).parse
+          [node, comments]
+        rescue ::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
+          RubyVM::AbstractSyntaxTree.parse(code)
+        rescue ::SyntaxError => e
+          raise Parser::SyntaxError, e.message
+        end
+
+        def map source
+          NodeProcessor.process(source.node, Region.new(source: source))
+        end
+
+        # def returns_from node
+        #   return [] unless Parser.is_ast_node?(node)
+        #   if node.type == :SCOPE
+        #     # node.children.select { |n| n.is_a?(RubyVM::AbstractSyntaxTree::Node) }.map { |n| DeepInference.get_return_nodes(n) }.flatten
+        #     DeepInference.get_return_nodes(node.children[2])
+        #   else
+        #     DeepInference.get_return_nodes(node)
+        #   end
+        # end
+
+        def references source, name
+          inner_node_references(name, source.node).map do |n|
+            rng = Range.from_node(n)
+            offset = Position.to_offset(source.code, rng.start)
+            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 Parser.rubyvm?
+            if Parser.is_ast_node?(top)
+              result.push top if match_rubyvm_node_to_ref(top, name)
+              top.children.each { |c| result.concat inner_node_references(name, c) }
+            end
+          else
+            if Parser.is_ast_node?(top) && 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
+          end
+          result
+        end
+
+        def match_rubyvm_node_to_ref(top, name)
+          top.children.select { |c| c.is_a?(Symbol) }.any? { |c| c.to_s == name } ||
+            top.children.select { |c| c.is_a?(Array) }.any? { |c| c.include?(name.to_sym) }
+        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
+          Ruby::VERSION
+        end
+
+        def is_ast_node? node
+          if Parser.rubyvm?
+            node.is_a?(RubyVM::AbstractSyntaxTree::Node)
+          else
+            node.is_a?(::Parser::AST::Node)
+          end
+        end
+
+        def node_range node
+          st = Position.new(node.first_lineno - 1, node.first_column)
+          en = Position.new(node.last_lineno - 1, node.last_column)
+          Range.new(st, en)
+        end
+
+        def recipient_node tree
+          tree.each_with_index do |node, idx|
+            return tree[idx + 1] if [:ARRAY, :ZARRAY, :LIST].include?(node.type) && tree[idx + 1] && [:FCALL, :VCALL, :CALL].include?(tree[idx + 1].type)
+          end
+          nil
+        end
+
+        def string_ranges node
+          return [] unless is_ast_node?(node)
+          result = []
+          if node.type == :STR
+            result.push Range.from_node(node)
+          elsif node.type == :DSTR
+            here = Range.from_node(node)
+            there = Range.from_node(node.children[1])
+            result.push Range.new(here.start, there.start)
+          end
+          node.children.each do |child|
+            result.concat string_ranges(child)
+          end
+          if node.type == :DSTR && node.children.last.nil?
+            # result.push Range.new(result.last.ending, result.last.ending)
+            last = node.children[-2]
+            unless last.nil?
+              rng = Range.from_node(last)
+              pos = Position.new(rng.ending.line, rng.ending.column - 1)
+              result.push Range.new(pos, pos)
+            end
+          end
+          result
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Parser
+    module Rubyvm
+      # A factory for generating chains from nodes.
+      #
+      class NodeChainer
+        include Rubyvm::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 Parser.is_ast_node?(n)
+          return generate_links(n.children[2]) if n.type == :SCOPE
+          return generate_links(n.children[0]) if n.type == :SPLAT
+          result = []
+          if n.type == :ITER
+            @in_block = true
+            result.concat generate_links(n.children[0])
+            @in_block = false
+          elsif n.type == :CALL || n.type == :OPCALL
+            n.children[0..-3].each do |c|
+              result.concat generate_links(c)
+            end
+            result.push Chain::Call.new(n.children[-2].to_s, node_to_argchains(n.children.last), @in_block || block_passed?(n))
+          elsif n.type == :ATTRASGN
+            result.concat generate_links(n.children[0])
+            result.push Chain::Call.new(n.children[1].to_s, node_to_argchains(n.children[2]), @in_block || block_passed?(n))
+          elsif n.type == :VCALL
+            result.push Chain::Call.new(n.children[0].to_s, [], @in_block || block_passed?(n))
+          elsif n.type == :FCALL
+            result.push Chain::Call.new(n.children[0].to_s, node_to_argchains(n.children[1]), @in_block || block_passed?(n))
+          elsif n.type == :SELF
+            result.push Chain::Head.new('self')
+          elsif [:SUPER, :ZSUPER].include?(n.type)
+            result.push Chain::Head.new('super')
+          elsif [:COLON2, :COLON3, :CONST].include?(n.type)
+            const = unpack_name(n)
+            result.push Chain::Constant.new(const)
+          elsif [:LVAR, :LASGN, :DVAR].include?(n.type)
+            result.push Chain::Call.new(n.children[0].to_s)
+          elsif [:IVAR, :IASGN].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, :GASGN].include?(n.type)
+            result.push Chain::GlobalVariable.new(n.children[0].to_s)
+          elsif n.type == :OP_ASGN_OR
+            result.concat generate_links n.children[2]
+          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 n.type == :begin
+            result.concat generate_links(n.children[0])
+          elsif n.type == :BLOCK_PASS
+            result.push Chain::BlockVariable.new("&#{n.children[1].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?(RubyVM::AbstractSyntaxTree::Node) && node.children.last.type == :BLOCK_PASS
+        end
+
+        def node_to_argchains node
+          # @todo Process array, splat, argscat
+          return [] unless Parser.is_ast_node?(node)
+          if [:ZARRAY, :ARRAY, :LIST].include?(node.type)
+            node.children[0..-2].map { |c| NodeChainer.chain(c) }
+          elsif node.type == :SPLAT
+            [NodeChainer.chain(node)]
+          elsif node.type == :ARGSCAT
+            result = node.children[0].children[0..-2].map { |c| NodeChainer.chain(c) }
+            result.push NodeChainer.chain(node.children[1])
+            # @todo Smelly instance variable access
+            result.last.instance_variable_set(:@splat, true)
+            result
+          elsif node.type == :BLOCK_PASS
+            result = node_to_argchains(node.children[0])
+            result.push Chain.new([Chain::BlockVariable.new("&#{node.children[1].children[0].to_s}")])
+            result
+          else
+            []
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,279 @@
+module Solargraph
+  module Parser
+    module Rubyvm
+      module NodeMethods
+        module_function
+
+        # @param node [RubyVM::AbstractSyntaxTree::Node]
+        # @return [String]
+        def unpack_name node
+          pack_name(node).join('::')
+        end
+
+        # @param node [RubyVM::AbstractSyntaxTree::Node]
+        # @return [Array<String>]
+        def pack_name(node)
+          parts = []
+          if node.is_a?(RubyVM::AbstractSyntaxTree::Node)
+            parts.push '' if node.type == :COLON3
+            node.children.each { |n|
+              if n.is_a?(RubyVM::AbstractSyntaxTree::Node)
+                parts += pack_name(n)
+              else
+                parts.push n unless n.nil?
+              end
+            }
+          end
+          parts
+        end
+
+        # @param node [RubyVM::AbstractSyntaxTree::Node]
+        # @return [String, nil]
+        def infer_literal_node_type node
+          return nil unless Parser.is_ast_node?(node)
+          case node.type
+          when :LIT, :STR
+            "::#{node.children.first.class.to_s}"
+          when :DSTR
+            "::String"
+          when :ARRAY, :ZARRAY, :LIST, :ZLIST
+            '::Array'
+          when :HASH
+            '::Hash'
+          when :DOT2, :DOT3
+            '::Range'
+          when :TRUE, :FALSE
+            '::Boolean'
+          when :SCOPE
+            infer_literal_node_type(node.children[2])
+          end
+        end
+
+        def returns_from node
+          return [] unless Parser.is_ast_node?(node)
+          if node.type == :SCOPE
+            # node.children.select { |n| n.is_a?(RubyVM::AbstractSyntaxTree::Node) }.map { |n| DeepInference.get_return_nodes(n) }.flatten
+            DeepInference.get_return_nodes(node.children[2])
+          else
+            DeepInference.get_return_nodes(node)
+          end
+        end
+
+        def const_nodes_from node
+          return [] unless Parser.is_ast_node?(node)
+          result = []
+          if [:CONST, :COLON2, :COLON3].include?(node.type)
+            result.push node
+          else
+            node.children.each { |child| result.concat const_nodes_from(child) }
+          end
+          result
+        end
+
+        def call_nodes_from node
+          return [] unless Parser.is_ast_node?(node)
+          result = []
+          if node.type == :ITER
+            result.push node.children[0]
+            node.children[1..-1].each { |child| result.concat call_nodes_from(child) }
+          elsif [:CALL, :VCALL, :FCALL, :ATTRASGN, :OPCALL].include?(node.type)
+            result.push node
+            node.children.each { |child| result.concat call_nodes_from(child) }
+          else
+            node.children.each { |child| result.concat call_nodes_from(child) }
+          end
+          result
+        end
+
+        def convert_hash node
+          return {} unless node?(node) && node.type == :HASH && node?(node.children[0])
+          result = {}
+          index = 0
+          until index > node.children[0].children.length - 2
+            k = node.children[0].children[index]
+            v = node.children[0].children[index + 1]
+            result[k.children[0]] = Solargraph::Parser.chain(v)
+            index += 2
+          end
+          result
+        end
+
+        def node? node
+          node.is_a?(RubyVM::AbstractSyntaxTree::Node)
+        end
+
+        # @param cursor [Solargraph::Source::Cursor]
+        def find_recipient_node cursor
+          if cursor.source.synchronized?
+            NodeMethods.synchronized_find_recipient_node cursor
+          else
+            NodeMethods.unsynchronized_find_recipient_node cursor
+          end
+        end
+
+        class << self
+          protected
+
+          def synchronized_find_recipient_node cursor
+            source = cursor.source
+            position = cursor.position
+            offset = cursor.offset
+            tree = source.tree_at(position.line, position.column)
+            tree.shift while tree.first && [:FCALL, :VCALL, :CALL].include?(tree.first.type) && !source.code_for(tree.first).strip.end_with?(')')
+            tree.each do |node|
+              if [:FCALL, :VCALL, :CALL].include?(node.type)
+                args = node.children.find { |c| Parser.is_ast_node?(c) && [:ARRAY, :ZARRAY, :LIST].include?(c.type) }
+                if args
+                  match = source.code[0..offset-1].match(/,[^\)]*\z/)
+                  rng = Solargraph::Range.from_node(args)
+                  if match
+                    rng = Solargraph::Range.new(rng.start, position)
+                  end
+                  return node if rng.contain?(position)
+                elsif source.code[0..offset-1] =~ /\(\s*$/
+                  break  unless source.code_for(node).strip.end_with?(')')
+                  return node
+                end
+              end
+            end
+            nil
+          end
+
+          def unsynchronized_find_recipient_node cursor
+            source = cursor.source
+            position = cursor.position
+            offset = cursor.offset
+            if source.code[0..offset-1] =~ /\([A-Zaz0-9_\s]*\z$/ #&& source.code[offset] == ')'
+              tree = source.tree_at(position.line, position.column - 1)
+              if tree.first && [:FCALL, :VCALL, :CALL].include?(tree.first.type)
+                return tree.first
+              else
+                return nil
+              end
+            else
+              match = source.code[0..offset-1].match(/[\(,][A-Zaz0-9_\s]*\z/)
+              if match
+                moved = Position.from_offset(source.code, offset - match[0].length)
+                tree = source.tree_at(moved.line, moved.column)
+                tree.shift if match[0].start_with?(',')
+                tree.shift while tree.first && ![:FCALL, :VCALL, :CALL].include?(tree.first.type)
+                if tree.first && [:FCALL, :VCALL, :CALL].include?(tree.first.type)
+                  return tree.first
+                end
+              end
+              return nil
+            end
+          end
+        end
+
+        module DeepInference
+          class << self
+            CONDITIONAL = [:IF, :UNLESS]
+            REDUCEABLE = [:BLOCK]
+            SKIPPABLE = [:DEFN, :DEFS, :CLASS, :SCLASS, :MODULE]
+
+            # @param node [Parser::AST::Node]
+            # @return [Array<Parser::AST::Node>]
+            def get_return_nodes node
+              return [] unless node.is_a?(RubyVM::AbstractSyntaxTree::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])
+              elsif node.type == :RESCUE
+                result.concat reduce_to_value_nodes([node.children[0]])
+                result.concat reduce_to_value_nodes(node.children[1..-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 == :ITER
+                result.push node
+                result.concat get_return_nodes_only(node.children[1])
+              elsif node.type == :CASE
+                node.children.each do |cc|
+                  result.concat reduce_to_value_nodes(cc.children[1..-1])
+                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?(RubyVM::AbstractSyntaxTree::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 CONDITIONAL.include?(node.type)
+                  result.concat get_return_nodes_only(node)
+                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?(RubyVM::AbstractSyntaxTree::Node)
+              result = []
+              nodes = parent.children.select{|n| n.is_a?(RubyVM::AbstractSyntaxTree::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?(RubyVM::AbstractSyntaxTree::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
+                  if node.children[0].nil?
+                    result.push nil
+                  else
+                    result.concat get_return_nodes(node.children[0])
+                  end
+                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])
+                elsif node.type == :RESBODY
+                  result.concat reduce_to_value_nodes([node.children[1]])
+                else
+                  result.push node
+                end
+              end
+              result
+            end
+          end
+        end
+      end
+    end
+  end
+end