solargraph 0.39.7

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

@@ -0,0 +1,284 @@
+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 node.type == :MASGN
+            # @todo We're treating a mass assignment as a call node, but the
+            #   type checker still needs the logic to handle it.
+            result.push node
+          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]
+            return {} unless node?(k)
+            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

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

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require 'solargraph/parser/node_processor'
+
+module Solargraph
+  module Parser
+    module Rubyvm
+      module NodeProcessors
+        autoload :ScopeNode,     'solargraph/parser/rubyvm/node_processors/scope_node'
+        autoload :BeginNode,     'solargraph/parser/rubyvm/node_processors/begin_node'
+        autoload :DefNode,       'solargraph/parser/rubyvm/node_processors/def_node'
+        autoload :DefsNode,      'solargraph/parser/rubyvm/node_processors/defs_node'
+        autoload :SendNode,      'solargraph/parser/rubyvm/node_processors/send_node'
+        autoload :NamespaceNode, 'solargraph/parser/rubyvm/node_processors/namespace_node'
+        autoload :SclassNode,    'solargraph/parser/rubyvm/node_processors/sclass_node'
+        autoload :ModuleNode,    'solargraph/parser/rubyvm/node_processors/module_node'
+        autoload :IvasgnNode,    'solargraph/parser/rubyvm/node_processors/ivasgn_node'
+        autoload :CvasgnNode,    'solargraph/parser/rubyvm/node_processors/cvasgn_node'
+        autoload :LvasgnNode,    'solargraph/parser/rubyvm/node_processors/lvasgn_node'
+        autoload :GvasgnNode,    'solargraph/parser/rubyvm/node_processors/gvasgn_node'
+        autoload :CasgnNode,     'solargraph/parser/rubyvm/node_processors/casgn_node'
+        autoload :AliasNode,     'solargraph/parser/rubyvm/node_processors/alias_node'
+        autoload :ArgsNode,      'solargraph/parser/rubyvm/node_processors/args_node'
+        autoload :OptArgNode,    'solargraph/parser/rubyvm/node_processors/opt_arg_node'
+        autoload :KwArgNode,     'solargraph/parser/rubyvm/node_processors/kw_arg_node'
+        autoload :BlockNode,     'solargraph/parser/rubyvm/node_processors/block_node'
+        autoload :OrasgnNode,    'solargraph/parser/rubyvm/node_processors/orasgn_node'
+        autoload :SymNode,       'solargraph/parser/rubyvm/node_processors/sym_node'
+        autoload :LitNode,       'solargraph/parser/rubyvm/node_processors/lit_node'
+        autoload :ResbodyNode,   'solargraph/parser/rubyvm/node_processors/resbody_node'
+      end
+    end
+
+    module NodeProcessor
+      register :SCOPE,      Rubyvm::NodeProcessors::ScopeNode
+      register :RESBODY,    Rubyvm::NodeProcessors::ResbodyNode
+      register :DEFN,       Rubyvm::NodeProcessors::DefNode
+      register :DEFS,       Rubyvm::NodeProcessors::DefsNode
+      register :CALL,       Rubyvm::NodeProcessors::SendNode
+      register :FCALL,      Rubyvm::NodeProcessors::SendNode
+      register :VCALL,      Rubyvm::NodeProcessors::SendNode
+      register :CLASS,      Rubyvm::NodeProcessors::NamespaceNode
+      register :MODULE,     Rubyvm::NodeProcessors::NamespaceNode
+      register :SCLASS,     Rubyvm::NodeProcessors::SclassNode
+      register :IASGN,      Rubyvm::NodeProcessors::IvasgnNode
+      register :CVASGN,     Rubyvm::NodeProcessors::CvasgnNode
+      register :LASGN,      Rubyvm::NodeProcessors::LvasgnNode
+      register :DASGN_CURR, Rubyvm::NodeProcessors::LvasgnNode
+      register :GASGN,      Rubyvm::NodeProcessors::GvasgnNode
+      register :CDECL,      Rubyvm::NodeProcessors::CasgnNode
+      register :ALIAS,      Rubyvm::NodeProcessors::AliasNode
+      register :ARGS,       Rubyvm::NodeProcessors::ArgsNode
+      register :OPT_ARG,    Rubyvm::NodeProcessors::OptArgNode
+      register :KW_ARG,     Rubyvm::NodeProcessors::KwArgNode
+      register :ITER,       Rubyvm::NodeProcessors::BlockNode
+      register :LAMBDA,     Rubyvm::NodeProcessors::BlockNode
+      register :OP_ASGN_OR, Rubyvm::NodeProcessors::OrasgnNode
+      register :LIT,        Rubyvm::NodeProcessors::LitNode
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Parser
+    module Rubyvm
+      module NodeProcessors
+        class AliasNode < Parser::NodeProcessor::Base
+          def process
+            loc = get_node_location(node)
+            pins.push Solargraph::Pin::MethodAlias.new(
+              location: loc,
+              closure: region.closure,
+              name: node.children[0].children[0].to_s,
+              original: node.children[1].children[0].to_s,
+              scope: region.scope || :instance
+            )
+            process_children
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Parser
+    module Rubyvm
+      module NodeProcessors
+        class ArgsNode < Parser::NodeProcessor::Base
+          def process
+            if region.closure.is_a?(Pin::BaseMethod) || region.closure.is_a?(Pin::Block)
+              node.children[0].times do |i|
+                locals.push Solargraph::Pin::Parameter.new(
+                  location: region.closure.location,
+                  closure: region.closure,
+                  comments: comments_for(node),
+                  name: region.lvars[i].to_s,
+                  presence: region.closure.location.range,
+                  decl: :arg
+                )
+                region.closure.parameters.push locals.last
+              end
+              # @todo Optional args, keyword args, etc.
+              if node.children[6]
+                locals.push Solargraph::Pin::Parameter.new(
+                  location: region.closure.location,
+                  closure: region.closure,
+                  comments: comments_for(node),
+                  name: node.children[6].to_s,
+                  presence: region.closure.location.range,
+                  decl: :restarg
+                )
+                region.closure.parameters.push locals.last
+              end
+              if node.children[8] && node.children[8].children.first
+                locals.push Solargraph::Pin::Parameter.new(
+                  location: region.closure.location,
+                  closure: region.closure,
+                  comments: comments_for(node),
+                  name: node.children[8].children.first.to_s,
+                  presence: region.closure.location.range,
+                  decl: :kwrestarg
+                )
+                region.closure.parameters.push locals.last
+              end
+              if node.children.last
+                locals.push Solargraph::Pin::Parameter.new(
+                  location: region.closure.location,
+                  closure: region.closure,
+                  comments: comments_for(node),
+                  name: node.children.last.to_s,
+                  presence: region.closure.location.range,
+                  decl: :blockarg
+                )
+                region.closure.parameters.push locals.last
+              end
+            end
+            process_children
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Parser
+    module Rubyvm
+      module NodeProcessors
+        class BeginNode < Parser::NodeProcessor::Base
+          def process
+            process_children
+          end
+        end
+      end
+    end
+  end
+end