solargraph 0.47.2 → 0.53.3

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

@@ -1,54 +0,0 @@
-# frozen_string_literal: true
-
-require 'solargraph/parser/node_processor'
-
-module Solargraph
-  module Parser
-    module Legacy
-      module NodeProcessors
-        autoload :BeginNode,     'solargraph/parser/legacy/node_processors/begin_node'
-        autoload :DefNode,       'solargraph/parser/legacy/node_processors/def_node'
-        autoload :DefsNode,      'solargraph/parser/legacy/node_processors/defs_node'
-        autoload :SendNode,      'solargraph/parser/legacy/node_processors/send_node'
-        autoload :NamespaceNode, 'solargraph/parser/legacy/node_processors/namespace_node'
-        autoload :SclassNode,    'solargraph/parser/legacy/node_processors/sclass_node'
-        autoload :ModuleNode,    'solargraph/parser/legacy/node_processors/module_node'
-        autoload :IvasgnNode,    'solargraph/parser/legacy/node_processors/ivasgn_node'
-        autoload :CvasgnNode,    'solargraph/parser/legacy/node_processors/cvasgn_node'
-        autoload :LvasgnNode,    'solargraph/parser/legacy/node_processors/lvasgn_node'
-        autoload :GvasgnNode,    'solargraph/parser/legacy/node_processors/gvasgn_node'
-        autoload :CasgnNode,     'solargraph/parser/legacy/node_processors/casgn_node'
-        autoload :AliasNode,     'solargraph/parser/legacy/node_processors/alias_node'
-        autoload :ArgsNode,      'solargraph/parser/legacy/node_processors/args_node'
-        autoload :BlockNode,     'solargraph/parser/legacy/node_processors/block_node'
-        autoload :OrasgnNode,    'solargraph/parser/legacy/node_processors/orasgn_node'
-        autoload :SymNode,       'solargraph/parser/legacy/node_processors/sym_node'
-        autoload :ResbodyNode,   'solargraph/parser/legacy/node_processors/resbody_node'
-      end
-    end
-
-    module NodeProcessor
-      register :source,  Legacy::NodeProcessors::BeginNode
-      register :begin,   Legacy::NodeProcessors::BeginNode
-      register :kwbegin, Legacy::NodeProcessors::BeginNode
-      register :rescue,  Legacy::NodeProcessors::BeginNode
-      register :resbody, Legacy::NodeProcessors::ResbodyNode
-      register :def,     Legacy::NodeProcessors::DefNode
-      register :defs,    Legacy::NodeProcessors::DefsNode
-      register :send,    Legacy::NodeProcessors::SendNode
-      register :class,   Legacy::NodeProcessors::NamespaceNode
-      register :module,  Legacy::NodeProcessors::NamespaceNode
-      register :sclass,  Legacy::NodeProcessors::SclassNode
-      register :ivasgn,  Legacy::NodeProcessors::IvasgnNode
-      register :cvasgn,  Legacy::NodeProcessors::CvasgnNode
-      register :lvasgn,  Legacy::NodeProcessors::LvasgnNode
-      register :gvasgn,  Legacy::NodeProcessors::GvasgnNode
-      register :casgn,   Legacy::NodeProcessors::CasgnNode
-      register :alias,   Legacy::NodeProcessors::AliasNode
-      register :args,    Legacy::NodeProcessors::ArgsNode
-      register :block,   Legacy::NodeProcessors::BlockNode
-      register :or_asgn, Legacy::NodeProcessors::OrasgnNode
-      register :sym,     Legacy::NodeProcessors::SymNode
-    end
-  end
-end

data/lib/solargraph/parser/legacy.rb

@@ -1,12 +0,0 @@
-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/rubyvm/class_methods.rb

@@ -1,144 +0,0 @@
-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).children[2]
-          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).children[2]
-        rescue ::SyntaxError => e
-          raise Parser::SyntaxError, e.message
-        end
-
-        def map source
-          NodeProcessor.process(source.node, Region.new(source: source))
-        end
-
-        def references source, name
-          if name.end_with?("=")
-            reg = /#{Regexp.escape name[0..-2]}\s*=/
-            extract_offset = ->(code, offset) { reg.match(code, offset).offset(0) }
-          else
-            extract_offset = ->(code, offset) { [soff = code.index(name, offset), soff + name.length] }
-          end
-          inner_node_references(name, source.node).map do |n|
-            rng = Range.from_node(n)
-            offset = Position.to_offset(source.code, rng.start)
-            soff, eoff = extract_offset[source.code, offset]
-            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 chain_string *args
-          NodeChainer.load_string *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 || here.ending)
-          end
-          node.children.each do |child|
-            result.concat string_ranges(child)
-          end
-          if node.type == :DSTR && node.children.last.nil?
-            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

@@ -1,160 +0,0 @@
-# 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 ? 1 : 0
-        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 += 1
-            result.concat generate_links(n.children[0])
-            @in_block -= 1
-          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 > 0 || block_passed?(n))
-          elsif n.type == :QCALL
-            n.children[0..-3].each do |c|
-              result.concat generate_links(c)
-            end
-            result.push Chain::QCall.new(n.children[-2].to_s, node_to_argchains(n.children.last), @in_block > 0 || 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 > 0 || block_passed?(n))
-          elsif n.type == :VCALL
-            result.push Chain::Call.new(n.children[0].to_s, [], @in_block > 0 || 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 > 0 || block_passed?(n))
-          elsif n.type == :SELF
-            result.push Chain::Head.new('self')
-          elsif n.type == :ZSUPER
-            result.push Chain::ZSuper.new('super', @in_block > 0 || block_passed?(n))
-          elsif n.type == :SUPER
-            result.push Chain::Call.new('super', node_to_argchains(n.children.last), @in_block > 0 || block_passed?(n))
-          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}")
-          elsif n.type == :HASH
-            result.push Chain::Hash.new('::Hash', hash_is_splatted?(n))
-          else
-            lit = infer_literal_node_type(n)
-            if lit
-              if lit == '::Hash'
-                result.push Chain::Hash.new(lit, hash_is_splatted?(n))
-              else
-                result.push Chain::Literal.new(lit)
-              end
-            else
-              result.push Chain::Link.new
-            end
-            # result.push (lit ? Chain::Literal.new(lit) : Chain::Link.new)
-          end
-          result
-        end
-
-        def hash_is_splatted? node
-          return false unless Parser.is_ast_node?(node.children[0]) && node.children[0].type == :LIST
-          list = node.children[0].children
-          eol = list.rindex(&:nil?)
-          eol && Parser.is_ast_node?(list[eol + 1])
-        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
-          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 == :ARGSPUSH
-            result = node_to_argchains(node.children[0])
-            result.push NodeChainer.chain(node.children[1]) if Parser.is_ast_node?(node.children[1])
-          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

@@ -1,315 +0,0 @@
-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
-          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
-            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 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
-          return false unless Parser.is_ast_node?(node)
-          splatted_node?(node) && node.children[0].children[1].type != :HASH
-        end
-
-        def any_splatted_call?(nodes)
-          nodes.any? { |n| splatted_call?(n) }
-        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
-
-          # @param cursor [Source::Cursor]
-          # @return [RubyVM::AbstractSyntaxTree::Node, nil]
-          def synchronized_find_recipient_node cursor
-            cursor = maybe_adjust_cursor(cursor)
-            source = cursor.source
-            position = cursor.position
-            offset = cursor.offset
-            tree = source.tree_at(position.line, position.column)
-              .select { |n| [:FCALL, :VCALL, :CALL].include?(n.type) }
-            unless source.repaired?
-              tree.shift while tree.first && !source.code_for(tree.first).strip.end_with?(')')
-            end
-            return tree.first if source.repaired? || source.code[0..offset-1] =~ /\(\s*$/
-            tree.each do |node|
-              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)
-              end
-            end
-            nil
-          end
-
-          # @param cursor [Source::Cursor]
-          # @return [Source::Cursor]
-          def maybe_adjust_cursor cursor
-            return cursor unless (cursor.source.repaired? && cursor.source.code[cursor.offset - 1] == '(') || [',', ' '].include?(cursor.source.code[cursor.offset - 1])
-            cursor.source.cursor_at([cursor.position.line, cursor.position.column - 1])
-          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$/
-              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[1..-1].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