spoom 1.2.3 → 1.3.0

data/lib/spoom/deadcode/remover.rb

@@ -0,0 +1,651 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Spoom
+  module Deadcode
+    class Remover
+      extend T::Sig
+
+      class Error < Spoom::Error; end
+
+      sig { params(context: Context).void }
+      def initialize(context)
+        @context = context
+      end
+
+      sig { params(kind: T.nilable(Definition::Kind), location: Location).returns(String) }
+      def remove_location(kind, location)
+        file = location.file
+
+        unless @context.file?(file)
+          raise Error, "Can't find file at #{file}"
+        end
+
+        node_remover = NodeRemover.new(@context.read(file), kind, location)
+        node_remover.apply_edit
+        node_remover.new_source
+      end
+
+      class NodeRemover
+        extend T::Sig
+
+        sig { returns(String) }
+        attr_reader :new_source
+
+        sig { params(source: String, kind: T.nilable(Definition::Kind), location: Location).void }
+        def initialize(source, kind, location)
+          @old_source = source
+          @new_source = T.let(source.dup, String)
+          @kind = kind
+          @location = location
+
+          @node_context = T.let(NodeFinder.find(source, location, kind), NodeContext)
+        end
+
+        sig { void }
+        def apply_edit
+          sclass_context = @node_context.sclass_context
+          if sclass_context
+            delete_node_and_comments_and_sigs(sclass_context)
+            return
+          end
+
+          node = @node_context.node
+          case node
+          when Prism::ClassNode, Prism::ModuleNode, Prism::DefNode
+            delete_node_and_comments_and_sigs(@node_context)
+          when Prism::ConstantWriteNode, Prism::ConstantOperatorWriteNode,
+                Prism::ConstantAndWriteNode, Prism::ConstantOrWriteNode,
+                Prism::ConstantPathWriteNode, Prism::ConstantPathOperatorWriteNode,
+                Prism::ConstantPathAndWriteNode, Prism::ConstantPathOrWriteNode,
+                Prism::ConstantTargetNode
+            delete_constant_assignment(@node_context)
+          when Prism::SymbolNode # for attr accessors
+            delete_attr_accessor(@node_context)
+          else
+            raise Error, "Unsupported node type: #{node.class}"
+          end
+        end
+
+        private
+
+        sig { params(context: NodeContext).void }
+        def delete_constant_assignment(context)
+          case context.node
+          when Prism::ConstantWriteNode, Prism::ConstantOperatorWriteNode,
+               Prism::ConstantAndWriteNode, Prism::ConstantOrWriteNode,
+               Prism::ConstantPathWriteNode, Prism::ConstantPathOperatorWriteNode,
+               Prism::ConstantPathAndWriteNode, Prism::ConstantPathOrWriteNode
+            # Nesting node is an assign, it means only one constant is assigned on the line
+            # so we can remove the whole assign
+            delete_node_and_comments_and_sigs(context)
+            return
+          end
+
+          # We're assigning multiple constants, we need to remove only the useless node
+          parent_context = context.parent_context
+          parent_node = parent_context.node
+          if parent_node.is_a?(Prism::ConstantWriteNode)
+            # Nesting node is an assign, it means only one constant is assigned on the line
+            # so we can remove the whole assign
+            delete_node_and_comments_and_sigs(parent_context)
+            return
+          elsif parent_node.is_a?(Prism::MultiWriteNode) && parent_node.lefts.size == 1
+            # Nesting node is a single left hand side, it means only one constant is assigned
+            # so we can remove the whole line
+            delete_node_and_comments_and_sigs(parent_context.parent_context)
+            return
+          end
+
+          # Nesting node is a multiple left hand side, it means multiple constants are assigned
+          # so we need to remove only the right node from the left hand side
+          node = context.node
+          prev_node = context.previous_node
+          next_node = context.next_node
+
+          if (prev_node && prev_node.location.end_line != node.location.start_line) &&
+              (next_node && next_node.location.start_line != node.location.end_line)
+            # We have a node before and after, but on different lines, we need to remove the whole line
+            #
+            # ~~~
+            # FOO,
+            # BAR, # we need to remove BAR
+            # BAZ = 42
+            # ~~~
+            delete_lines(node.location.start_line, node.location.end_line)
+          elsif prev_node && next_node.is_a?(Prism::ConstantTargetNode)
+            # We have a node before and after one the same line, just remove the part of the line
+            #
+            # ~~~
+            # FOO, BAR, BAZ = 42 # we need to remove BAR
+            # ~~~
+            replace_chars(prev_node.location.end_offset, next_node.location.start_offset, ", ")
+          elsif prev_node
+            # We have a node before, on the same line, but no node after, just remove the part of the line
+            #
+            # ~~~
+            # FOO, BAR = 42 # we need to remove BAR
+            # ~~~
+            nesting_assign = T.cast(parent_context.node, Prism::MultiWriteNode)
+
+            rparen_loc = nesting_assign.rparen_loc
+            if rparen_loc
+              # We have an assign with parenthesis, we need to remove the part of the line until the closing parenthesis
+              delete_chars(prev_node.location.end_offset, rparen_loc.start_offset)
+            else
+              # We don't have a parenthesis, we need to remove the part of the line until the operator
+              replace_chars(prev_node.location.end_offset, nesting_assign.operator_loc.start_offset, " ")
+            end
+          elsif next_node.is_a?(Prism::ConstantTargetNode)
+            # We don't have a node before but a node after on the same line, just remove the part of the line
+            #
+            # ~~~
+            # FOO, BAR = 42 # we need to remove FOO
+            # ~~~
+            delete_chars(node.location.start_offset, next_node.location.start_offset)
+          else
+            # Should have been removed as a single MLHS node
+            raise "Unexpected case while removing constant assignment"
+          end
+        end
+
+        sig { params(context: NodeContext).void }
+        def delete_attr_accessor(context)
+          args_context = context.parent_context
+          send_context = args_context.parent_context
+          send_context = send_context.parent_context if send_context.node.is_a?(Prism::ArgumentsNode)
+
+          send_node = T.cast(send_context.node, Prism::CallNode)
+          need_accessor = send_node.name == :attr_accessor
+
+          if args_context.node.child_nodes.size == 1
+            # Only one accessor is defined, we can remove the whole node
+            delete_node_and_comments_and_sigs(send_context)
+            insert_accessor(context.node, send_context, was_removed: true) if need_accessor
+            return
+          end
+
+          prev_node = context.previous_node
+          next_node = context.next_node
+
+          if (prev_node && prev_node.location.end_line != context.node.location.start_line) &&
+              (next_node && next_node.location.start_line != context.node.location.end_line)
+            # We have a node before and after, but on different lines, we need to remove the whole line
+            #
+            # ~~~
+            # attr_reader(
+            #  :foo,
+            #  :bar, # attr to remove
+            #  :baz,
+            # )
+            # ~~~
+            delete_lines(context.node.location.start_line, context.node.location.end_line)
+          elsif prev_node && next_node
+            # We have a node before and after one the same line, just remove the part of the line
+            #
+            # ~~~
+            # attr_reader :foo, :bar, :baz # we need to remove bar
+            # ~~~
+            replace_chars(prev_node.location.end_offset, next_node.location.start_offset, ", ")
+          elsif prev_node
+            # We have a node before, on the same line, but no node after, just remove the part of the line
+            #
+            # ~~~
+            # attr_reader :foo, :bar, :baz # we need to remove baz
+            # ~~~
+            delete_chars(prev_node.location.end_offset, context.node.location.end_offset)
+          elsif next_node
+            # We don't have a node before but a node after on the same line, just remove the part of the line
+            #
+            # ~~~
+            # attr_reader :foo, :bar, :baz # we need to remove foo
+            # ~~~
+            delete_chars(context.node.location.start_offset, next_node.location.start_offset)
+          else
+            raise "Unexpected case while removing attr_accessor"
+          end
+
+          insert_accessor(context.node, send_context, was_removed: false) if need_accessor
+        end
+
+        sig do
+          params(
+            node: Prism::Node,
+            send_context: NodeContext,
+            was_removed: T::Boolean,
+          ).void
+        end
+        def insert_accessor(node, send_context, was_removed:)
+          name = node.slice
+          code = case @kind
+          when Definition::Kind::AttrReader
+            "attr_writer #{name}"
+          when Definition::Kind::AttrWriter
+            "attr_reader #{name}"
+          end
+
+          indent = " " * send_context.node.location.start_column
+
+          sig = send_context.attached_sig
+          sig_string = transform_sig(sig, name: name, kind: @kind) if sig
+
+          node_after = send_context.next_node
+
+          if was_removed
+            first_node = send_context.attached_sigs.first || send_context.node
+            at_line = first_node.location.start_line - 1
+
+            prev_context = NodeContext.new(@old_source, @node_context.comments, first_node, send_context.nesting)
+            node_before = prev_context.previous_node
+
+            new_line_before = node_before && send_context.node.location.start_line - node_before.location.end_line < 2
+            new_line_after = node_after && node_after.location.start_line - send_context.node.location.end_line <= 2
+          else
+            at_line = send_context.node.location.end_line
+            new_line_before = true
+            new_line_after = node_after && node_after.location.start_line - send_context.node.location.end_line < 2
+          end
+
+          lines_to_insert = String.new
+          lines_to_insert << "\n" if new_line_before
+          lines_to_insert << "#{indent}#{sig_string}\n" if sig_string
+          lines_to_insert << "#{indent}#{code}\n"
+          lines_to_insert << "\n" if new_line_after
+
+          lines = @new_source.lines
+          lines.insert(at_line, lines_to_insert)
+          @new_source = lines.join
+        end
+
+        sig { params(context: NodeContext).void }
+        def delete_node_and_comments_and_sigs(context)
+          start_line = context.node.location.start_line
+          end_line = context.node.location.end_line
+
+          # TODO: remove once Prism location are fixed
+          node = context.node
+          case node
+          when Prism::ConstantWriteNode, Prism::ConstantOperatorWriteNode,
+                Prism::ConstantAndWriteNode, Prism::ConstantOrWriteNode,
+                Prism::ConstantPathWriteNode, Prism::ConstantPathOperatorWriteNode,
+                Prism::ConstantPathAndWriteNode, Prism::ConstantPathOrWriteNode
+            value = node.value
+            if value.is_a?(Prism::StringNode)
+              end_line = value.closing_loc&.start_line || value.location.end_line
+            end
+          end
+
+          # Adjust the lines to remove to include sigs attached to the node
+          first_node = context.attached_sigs.first || context.node
+          start_line = first_node.location.start_line if first_node
+
+          # Adjust the lines to remove to include comments attached to the node
+          first_comment = context.attached_comments(first_node).first
+          start_line = first_comment.location.start_line if first_comment
+
+          # Adjust the lines to remove to include previous blank lines
+          prev_context = NodeContext.new(@old_source, @node_context.comments, first_node, context.nesting)
+          before = T.let(prev_context.previous_node, T.nilable(T.any(Prism::Node, Prism::Comment)))
+
+          # There may be an unrelated comment between the current node and the one before
+          # if there is, we only want to delete lines up to the last comment found
+          if before
+            to_node = first_comment || node
+            comment = @node_context.comments_between_lines(before.location.end_line, to_node.location.start_line).last
+            before = comment if comment
+          end
+
+          if before && before.location.end_line < start_line - 1
+            # There is a node before and a blank line
+            start_line = before.location.end_line + 1
+          elsif before.nil?
+            # There is no node before, check if there is a blank line
+            parent_context = context.parent_context
+            # With Prism the StatementsNode location starts at the first line of the first node
+            parent_context = parent_context.parent_context if parent_context.node.is_a?(Prism::StatementsNode)
+            if parent_context.node.location.start_line < start_line - 1
+              # There is a blank line before the node
+              start_line = parent_context.node.location.start_line + 1
+            end
+          end
+
+          # Adjust the lines to remove to include following blank lines
+          after = context.next_node
+          if before.nil? && after && after.location.start_line > end_line + 1
+            end_line = after.location.end_line - 1
+          elsif after.nil? && context.parent_node.location.end_line > end_line + 1
+            end_line = context.parent_node.location.end_line - 1
+          end
+
+          delete_lines(start_line, end_line)
+        end
+
+        sig { params(start_line: Integer, end_line: Integer).void }
+        def delete_lines(start_line, end_line)
+          lines = @new_source.lines
+          lines[start_line - 1...end_line] = []
+          @new_source = lines.join
+        end
+
+        sig { params(start_char: Integer, end_char: Integer).void }
+        def delete_chars(start_char, end_char)
+          @new_source[start_char...end_char] = ""
+        end
+
+        sig { params(start_char: Integer, end_char: Integer, replacement: String).void }
+        def replace_chars(start_char, end_char, replacement)
+          @new_source[start_char...end_char] = replacement
+        end
+
+        sig { params(node: Prism::CallNode, name: String, kind: T.nilable(Definition::Kind)).returns(String) }
+        def transform_sig(node, name:, kind:)
+          type = T.let(nil, T.nilable(String))
+
+          block = T.cast(node.block, Prism::BlockNode)
+          statements = T.cast(block.body, Prism::StatementsNode)
+
+          statements.body.each do |call|
+            next unless call.is_a?(Prism::CallNode)
+            next unless call.name == :returns
+
+            args = call.arguments
+            next unless args
+
+            first = args.arguments.first
+            next unless first
+
+            type = first.slice
+          end
+
+          name = name.delete_prefix(":")
+          type = T.must(type)
+
+          case kind
+          when Definition::Kind::AttrReader
+            "sig { params(#{name}: #{type}).returns(#{type}) }"
+          else
+            "sig { returns(#{type}) }"
+          end
+        end
+      end
+
+      class NodeContext
+        extend T::Sig
+
+        sig { returns(T::Hash[Integer, Prism::Comment]) }
+        attr_reader :comments
+
+        sig { returns(Prism::Node) }
+        attr_reader :node
+
+        sig { returns(T::Array[Prism::Node]) }
+        attr_accessor :nesting
+
+        sig do
+          params(
+            source: String,
+            comments: T::Hash[Integer, Prism::Comment],
+            node: Prism::Node,
+            nesting: T::Array[Prism::Node],
+          ).void
+        end
+        def initialize(source, comments, node, nesting)
+          @source = source
+          @comments = comments
+          @node = node
+          @nesting = nesting
+        end
+
+        sig { returns(Prism::Node) }
+        def parent_node
+          parent = @nesting.last
+          raise "No parent for node #{node}" unless parent
+
+          parent
+        end
+
+        sig { returns(NodeContext) }
+        def parent_context
+          nesting = @nesting.dup
+          parent = nesting.pop
+          raise "No parent context for node #{@node}" unless parent
+
+          NodeContext.new(@source, @comments, parent, nesting)
+        end
+
+        sig { returns(T::Array[Prism::Node]) }
+        def previous_nodes
+          parent = parent_node
+          child_nodes = parent.child_nodes.compact
+
+          index = child_nodes.index(@node)
+          raise "Node #{@node} not found in parent #{parent}" unless index
+
+          T.must(child_nodes[0...index])
+        end
+
+        sig { returns(T.nilable(Prism::Node)) }
+        def previous_node
+          previous_nodes.last
+        end
+
+        sig { returns(T::Array[Prism::Node]) }
+        def next_nodes
+          parent = parent_node
+          child_nodes = parent.child_nodes.compact
+
+          index = child_nodes.index(node)
+          raise "Node #{@node} not found in nesting node #{parent}" unless index
+
+          T.must(child_nodes.compact[(index + 1)..-1])
+        end
+
+        sig { returns(T.nilable(Prism::Node)) }
+        def next_node
+          next_nodes.first
+        end
+
+        sig { returns(T.nilable(NodeContext)) }
+        def sclass_context
+          sclass = T.let(nil, T.nilable(Prism::SingletonClassNode))
+
+          nesting = @nesting.dup
+          until nesting.empty? || sclass
+            node = nesting.pop
+            next unless node.is_a?(Prism::SingletonClassNode)
+
+            sclass = node
+          end
+
+          return unless sclass.is_a?(Prism::SingletonClassNode)
+
+          body = sclass.body
+          return NodeContext.new(@source, @comments, sclass, nesting) unless body.is_a?(Prism::StatementsNode)
+
+          nodes = body.child_nodes.reject do |node|
+            sorbet_signature?(node) || sorbet_extend_sig?(node)
+          end
+
+          if nodes.size <= 1
+            return NodeContext.new(@source, @comments, sclass, nesting)
+          end
+
+          nil
+        end
+
+        sig { params(node: T.nilable(Prism::Node)).returns(T::Boolean) }
+        def sorbet_signature?(node)
+          node.is_a?(Prism::CallNode) && node.name == :sig
+        end
+
+        sig { params(node: T.nilable(Prism::Node)).returns(T::Boolean) }
+        def sorbet_extend_sig?(node)
+          return false unless node.is_a?(Prism::CallNode)
+          return false unless node.name == :extend
+
+          args = node.arguments
+          return false unless args
+          return false unless args.arguments.size == 1
+
+          args.arguments.first&.slice == "T::Sig"
+        end
+
+        sig { params(start_line: Integer, end_line: Integer).returns(T::Array[Prism::Comment]) }
+        def comments_between_lines(start_line, end_line)
+          comments = T.let([], T::Array[Prism::Comment])
+
+          (start_line + 1).upto(end_line - 1) do |line|
+            comment = @comments[line]
+            comments << comment if comment
+          end
+
+          comments
+        end
+
+        sig { params(node: Prism::Node).returns(T::Array[Prism::Comment]) }
+        def attached_comments(node)
+          comments = T.let([], T::Array[Prism::Comment])
+
+          start_line = node.location.start_line - 1
+          start_line.downto(1) do |line|
+            comment = @comments[line]
+            break unless comment
+
+            comments << comment
+          end
+
+          comments.reverse
+        end
+
+        sig { returns(T::Array[Prism::Node]) }
+        def attached_sigs
+          nodes = T.let([], T::Array[Prism::Node])
+
+          previous_nodes.reverse_each do |prev_node|
+            break unless sorbet_signature?(prev_node)
+
+            nodes << prev_node
+          end
+
+          nodes.reverse
+        end
+
+        sig { returns(T.nilable(Prism::CallNode)) }
+        def attached_sig
+          previous_nodes.reverse_each do |node|
+            if node.is_a?(Prism::Comment)
+              next
+            elsif sorbet_signature?(node)
+              return T.cast(node, Prism::CallNode)
+            else
+              break
+            end
+          end
+
+          nil
+        end
+      end
+
+      class NodeFinder < Visitor
+        extend T::Sig
+
+        class << self
+          extend T::Sig
+
+          sig { params(source: String, location: Location, kind: T.nilable(Definition::Kind)).returns(NodeContext) }
+          def find(source, location, kind)
+            result = Prism.parse(source)
+
+            unless result.success?
+              message = result.errors.map do |e|
+                "#{e.message} (at #{e.location.start_line}:#{e.location.start_column})."
+              end.join(" ")
+
+              raise ParserError, "Error while parsing #{location.file}: #{message}"
+            end
+
+            visitor = new(location)
+            visitor.visit(result.value)
+
+            node = visitor.node
+            unless node
+              raise Error, "Can't find node at #{location}"
+            end
+
+            if kind && !node_match_kind?(node, kind)
+              raise Error, "Can't find node at #{location}, expected #{kind} but got #{node.class}"
+            end
+
+            comments_by_line = T.let(
+              result.comments.to_h do |comment|
+                [comment.location.start_line, comment]
+              end,
+              T::Hash[Integer, Prism::Comment],
+            )
+
+            NodeContext.new(source, comments_by_line, node, visitor.nodes_nesting)
+          end
+
+          sig { params(node: Prism::Node, kind: Definition::Kind).returns(T::Boolean) }
+          def node_match_kind?(node, kind)
+            case kind
+            when Definition::Kind::AttrReader, Definition::Kind::AttrWriter
+              node.is_a?(Prism::SymbolNode)
+            when Definition::Kind::Class
+              node.is_a?(Prism::ClassNode)
+            when Definition::Kind::Constant
+              node.is_a?(Prism::ConstantWriteNode) ||
+                node.is_a?(Prism::ConstantAndWriteNode) ||
+                node.is_a?(Prism::ConstantOrWriteNode) ||
+                node.is_a?(Prism::ConstantOperatorWriteNode) ||
+                node.is_a?(Prism::ConstantPathWriteNode) ||
+                node.is_a?(Prism::ConstantPathAndWriteNode) ||
+                node.is_a?(Prism::ConstantPathOrWriteNode) ||
+                node.is_a?(Prism::ConstantPathOperatorWriteNode) ||
+                node.is_a?(Prism::ConstantTargetNode)
+            when Definition::Kind::Method
+              node.is_a?(Prism::DefNode)
+            when Definition::Kind::Module
+              node.is_a?(Prism::ModuleNode)
+            end
+          end
+        end
+
+        sig { returns(T.nilable(Prism::Node)) }
+        attr_reader :node
+
+        sig { returns(T::Array[Prism::Node]) }
+        attr_reader :nodes_nesting
+
+        sig { params(location: Location).void }
+        def initialize(location)
+          super()
+          @location = location
+          @node = T.let(nil, T.nilable(Prism::Node))
+          @nodes_nesting = T.let([], T::Array[Prism::Node])
+        end
+
+        sig { override.params(node: T.nilable(Prism::Node)).void }
+        def visit(node)
+          return unless node
+
+          location = Location.from_prism(@location.file, node.location)
+
+          if location == @location
+            # We found the node we're looking for at `@location`
+            @node = node
+
+            # There may be a more precise child inside the node that also matches `@location`, let's visit them
+            @nodes_nesting << node
+            super(node)
+            @nodes_nesting.pop if @nodes_nesting.last == @node
+          elsif location.include?(@location)
+            # The node we're looking for is inside `node`, let's visit it
+            @nodes_nesting << node
+            super(node)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/spoom/deadcode/send.rb

@@ -3,16 +3,37 @@
 
 module Spoom
   module Deadcode
-    # An abstraction to simplify handling of SyntaxTree::CallNode, SyntaxTree::Command, SyntaxTree::CommandCall and
-    # SyntaxTree::VCall nodes.
+    # An abstraction to simplify handling of Prism::CallNode nodes.
     class Send < T::Struct
       extend T::Sig
 
-      const :node, SyntaxTree::Node
+      const :node, Prism::CallNode
       const :name, String
-      const :recv, T.nilable(SyntaxTree::Node), default: nil
-      const :args, T::Array[SyntaxTree::Node], default: []
-      const :block, T.nilable(SyntaxTree::Node), default: nil
+      const :recv, T.nilable(Prism::Node), default: nil
+      const :args, T::Array[Prism::Node], default: []
+      const :block, T.nilable(Prism::Node), default: nil
+
+      sig do
+        type_parameters(:T)
+          .params(arg_type: T::Class[T.type_parameter(:T)], block: T.proc.params(arg: T.type_parameter(:T)).void)
+          .void
+      end
+      def each_arg(arg_type, &block)
+        args.each do |arg|
+          yield(T.unsafe(arg)) if arg.is_a?(arg_type)
+        end
+      end
+
+      sig { params(block: T.proc.params(key: Prism::Node, value: T.nilable(Prism::Node)).void).void }
+      def each_arg_assoc(&block)
+        args.each do |arg|
+          next unless arg.is_a?(Prism::KeywordHashNode) || arg.is_a?(Prism::HashNode)
+
+          arg.elements.each do |assoc|
+            yield(assoc.key, assoc.value) if assoc.is_a?(Prism::AssocNode)
+          end
+        end
+      end
     end
   end
 end