spoom 1.2.0 → 1.2.2

data/lib/spoom/deadcode/index.rb

@@ -0,0 +1,61 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Spoom
+  module Deadcode
+    class Index
+      extend T::Sig
+
+      sig { returns(T::Hash[String, T::Array[Definition]]) }
+      attr_reader :definitions
+
+      sig { returns(T::Hash[String, T::Array[Reference]]) }
+      attr_reader :references
+
+      sig { void }
+      def initialize
+        @definitions = T.let({}, T::Hash[String, T::Array[Definition]])
+        @references = T.let({}, T::Hash[String, T::Array[Reference]])
+      end
+
+      # Indexing
+
+      sig { params(definition: Definition).void }
+      def define(definition)
+        (@definitions[definition.name] ||= []) << definition
+      end
+
+      sig { params(reference: Reference).void }
+      def reference(reference)
+        (@references[reference.name] ||= []) << reference
+      end
+
+      # Mark all definitions having a reference of the same name as `alive`
+      #
+      # To be called once all the files have been indexed and all the definitions and references discovered.
+      sig { void }
+      def finalize!
+        @references.keys.each do |name|
+          definitions_for_name(name).each(&:alive!)
+        end
+      end
+
+      # Utils
+
+      sig { params(name: String).returns(T::Array[Definition]) }
+      def definitions_for_name(name)
+        @definitions[name] || []
+      end
+
+      sig { returns(T::Array[Definition]) }
+      def all_definitions
+        @definitions.values.flatten
+      end
+
+      sig { returns(T::Array[Reference]) }
+      def all_references
+        @references.values.flatten
+      end
+    end
+  end
+end

data/lib/spoom/deadcode/indexer.rb

@@ -0,0 +1,394 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Spoom
+  module Deadcode
+    class Indexer < SyntaxTree::Visitor
+      extend T::Sig
+
+      sig { returns(String) }
+      attr_reader :path, :file_name
+
+      sig { returns(Index) }
+      attr_reader :index
+
+      sig { params(path: String, source: String, index: Index).void }
+      def initialize(path, source, index)
+        super()
+
+        @path = path
+        @file_name = T.let(File.basename(path), String)
+        @source = source
+        @index = index
+        @previous_node = T.let(nil, T.nilable(SyntaxTree::Node))
+        @names_nesting = T.let([], T::Array[String])
+        @nodes_nesting = T.let([], T::Array[SyntaxTree::Node])
+        @in_const_field = T.let(false, T::Boolean)
+        @in_opassign = T.let(false, T::Boolean)
+        @in_symbol_literal = T.let(false, T::Boolean)
+      end
+
+      # Visit
+
+      sig { override.params(node: T.nilable(SyntaxTree::Node)).void }
+      def visit(node)
+        return unless node
+
+        @nodes_nesting << node
+        super
+        @nodes_nesting.pop
+        @previous_node = node
+      end
+
+      sig { override.params(node: SyntaxTree::AliasNode).void }
+      def visit_alias(node)
+        reference_method(node_string(node.right), node)
+      end
+
+      sig { override.params(node: SyntaxTree::ARef).void }
+      def visit_aref(node)
+        super
+
+        reference_method("[]", node)
+      end
+
+      sig { override.params(node: SyntaxTree::ARefField).void }
+      def visit_aref_field(node)
+        super
+
+        reference_method("[]=", node)
+      end
+
+      sig { override.params(node: SyntaxTree::ArgBlock).void }
+      def visit_arg_block(node)
+        value = node.value
+
+        case value
+        when SyntaxTree::SymbolLiteral
+          # If the block call is something like `x.select(&:foo)`, we need to reference the `foo` method
+          reference_method(symbol_string(value), node)
+        when SyntaxTree::VCall
+          # If the block call is something like `x.select { ... }`, we need to visit the block
+          super
+        end
+      end
+
+      sig { override.params(node: SyntaxTree::Binary).void }
+      def visit_binary(node)
+        super
+
+        op = node.operator
+
+        # Reference the operator itself
+        reference_method(op.to_s, node)
+
+        case op
+        when :<, :>, :<=, :>=
+          # For comparison operators, we also reference the `<=>` method
+          reference_method("<=>", node)
+        end
+      end
+
+      sig { override.params(node: SyntaxTree::CallNode).void }
+      def visit_call(node)
+        visit_send(
+          Send.new(
+            node: node,
+            name: node_string(node.message),
+            recv: node.receiver,
+            args: call_args(node.arguments),
+          ),
+        )
+      end
+
+      sig { override.params(node: SyntaxTree::ClassDeclaration).void }
+      def visit_class(node)
+        const_name = node_string(node.constant)
+        @names_nesting << const_name
+        define_class(T.must(const_name.split("::").last), @names_nesting.join("::"), node)
+
+        # We do not call `super` here because we don't want to visit the `constant` again
+        visit(node.superclass) if node.superclass
+        visit(node.bodystmt)
+
+        @names_nesting.pop
+      end
+
+      sig { override.params(node: SyntaxTree::Command).void }
+      def visit_command(node)
+        visit_send(
+          Send.new(
+            node: node,
+            name: node_string(node.message),
+            args: call_args(node.arguments),
+            block: node.block,
+          ),
+        )
+      end
+
+      sig { override.params(node: SyntaxTree::CommandCall).void }
+      def visit_command_call(node)
+        visit_send(
+          Send.new(
+            node: node,
+            name: node_string(node.message),
+            recv: node.receiver,
+            args: call_args(node.arguments),
+            block: node.block,
+          ),
+        )
+      end
+
+      sig { override.params(node: SyntaxTree::Const).void }
+      def visit_const(node)
+        reference_constant(node.value, node) unless @in_symbol_literal
+      end
+
+      sig { override.params(node: SyntaxTree::ConstPathField).void }
+      def visit_const_path_field(node)
+        # We do not call `super` here because we don't want to visit the `constant` again
+        visit(node.parent)
+
+        name = node.constant.value
+        full_name = [*@names_nesting, node_string(node.parent), name].join("::")
+        define_constant(name, full_name, node)
+      end
+
+      sig { override.params(node: SyntaxTree::DefNode).void }
+      def visit_def(node)
+        super
+
+        name = node_string(node.name)
+        define_method(name, [*@names_nesting, name].join("::"), node)
+      end
+
+      sig { override.params(node: SyntaxTree::Field).void }
+      def visit_field(node)
+        visit(node.parent)
+
+        name = node.name
+        case name
+        when SyntaxTree::Const
+          name = name.value
+          full_name = [*@names_nesting, node_string(node.parent), name].join("::")
+          define_constant(name, full_name, node)
+        when SyntaxTree::Ident
+          reference_method(name.value, node) if @in_opassign
+          reference_method("#{name.value}=", node)
+        end
+      end
+
+      sig { override.params(node: SyntaxTree::ModuleDeclaration).void }
+      def visit_module(node)
+        const_name = node_string(node.constant)
+        @names_nesting << const_name
+        define_module(T.must(const_name.split("::").last), @names_nesting.join("::"), node)
+
+        # We do not call `super` here because we don't want to visit the `constant` again
+        visit(node.bodystmt)
+
+        @names_nesting.pop
+      end
+
+      sig { override.params(node: SyntaxTree::OpAssign).void }
+      def visit_opassign(node)
+        # Both `FOO = x` and `FOO += x` yield a VarField node, but the former is a constant definition and the latter is
+        # a constant reference. We need to distinguish between the two cases.
+        @in_opassign = true
+        super
+        @in_opassign = false
+      end
+
+      sig { params(send: Send).void }
+      def visit_send(send)
+        visit(send.recv)
+
+        case send.name
+        when "attr_reader"
+          send.args.each do |arg|
+            next unless arg.is_a?(SyntaxTree::SymbolLiteral)
+
+            name = symbol_string(arg)
+            define_attr_reader(name, [*@names_nesting, name].join("::"), arg)
+          end
+        when "attr_writer"
+          send.args.each do |arg|
+            next unless arg.is_a?(SyntaxTree::SymbolLiteral)
+
+            name = symbol_string(arg)
+            define_attr_writer("#{name}=", "#{[*@names_nesting, name].join("::")}=", arg)
+          end
+        when "attr_accessor"
+          send.args.each do |arg|
+            next unless arg.is_a?(SyntaxTree::SymbolLiteral)
+
+            name = symbol_string(arg)
+            full_name = [*@names_nesting, name].join("::")
+            define_attr_reader(name, full_name, arg)
+            define_attr_writer("#{name}=", "#{full_name}=", arg)
+          end
+        else
+          reference_method(send.name, send.node)
+          visit_all(send.args)
+          visit(send.block)
+        end
+      end
+
+      sig { override.params(node: SyntaxTree::SymbolLiteral).void }
+      def visit_symbol_literal(node)
+        # Something like `:FOO` will yield a Const node but we do not want to treat it as a constant reference.
+        # So we need to distinguish between the two cases.
+        @in_symbol_literal = true
+        super
+        @in_symbol_literal = false
+      end
+
+      sig { override.params(node: SyntaxTree::TopConstField).void }
+      def visit_top_const_field(node)
+        define_constant(node.constant.value, node.constant.value, node)
+      end
+
+      sig { override.params(node: SyntaxTree::VarField).void }
+      def visit_var_field(node)
+        value = node.value
+        case value
+        when SyntaxTree::Const
+          if @in_opassign
+            reference_constant(value.value, node)
+          else
+            name = value.value
+            define_constant(name, [*@names_nesting, name].join("::"), node)
+          end
+        when SyntaxTree::Ident
+          reference_method(value.value, node) if @in_opassign
+          reference_method("#{value.value}=", node)
+        end
+      end
+
+      sig { override.params(node: SyntaxTree::VCall).void }
+      def visit_vcall(node)
+        visit_send(Send.new(node: node, name: node_string(node.value)))
+      end
+
+      private
+
+      # Definition indexing
+
+      sig { params(name: String, full_name: String, node: SyntaxTree::Node).void }
+      def define_attr_reader(name, full_name, node)
+        definition = Definition.new(
+          kind: Definition::Kind::AttrReader,
+          name: name,
+          full_name: full_name,
+          location: node_location(node),
+        )
+        @index.define(definition)
+      end
+
+      sig { params(name: String, full_name: String, node: SyntaxTree::Node).void }
+      def define_attr_writer(name, full_name, node)
+        definition = Definition.new(
+          kind: Definition::Kind::AttrWriter,
+          name: name,
+          full_name: full_name,
+          location: node_location(node),
+        )
+        @index.define(definition)
+      end
+
+      sig { params(name: String, full_name: String, node: SyntaxTree::Node).void }
+      def define_class(name, full_name, node)
+        definition = Definition.new(
+          kind: Definition::Kind::Class,
+          name: name,
+          full_name: full_name,
+          location: node_location(node),
+        )
+        @index.define(definition)
+      end
+
+      sig { params(name: String, full_name: String, node: SyntaxTree::Node).void }
+      def define_constant(name, full_name, node)
+        definition = Definition.new(
+          kind: Definition::Kind::Constant,
+          name: name,
+          full_name: full_name,
+          location: node_location(node),
+        )
+        @index.define(definition)
+      end
+
+      sig { params(name: String, full_name: String, node: SyntaxTree::Node).void }
+      def define_method(name, full_name, node)
+        definition = Definition.new(
+          kind: Definition::Kind::Method,
+          name: name,
+          full_name: full_name,
+          location: node_location(node),
+        )
+        @index.define(definition)
+      end
+
+      sig { params(name: String, full_name: String, node: SyntaxTree::Node).void }
+      def define_module(name, full_name, node)
+        definition = Definition.new(
+          kind: Definition::Kind::Module,
+          name: name,
+          full_name: full_name,
+          location: node_location(node),
+        )
+        @index.define(definition)
+      end
+
+      # Reference indexing
+
+      sig { params(name: String, node: SyntaxTree::Node).void }
+      def reference_constant(name, node)
+        @index.reference(Reference.new(name: name, kind: Reference::Kind::Constant, location: node_location(node)))
+      end
+
+      sig { params(name: String, node: SyntaxTree::Node).void }
+      def reference_method(name, node)
+        @index.reference(Reference.new(name: name, kind: Reference::Kind::Method, location: node_location(node)))
+      end
+
+      # Node utils
+
+      sig { params(node: T.any(Symbol, SyntaxTree::Node)).returns(String) }
+      def node_string(node)
+        case node
+        when Symbol
+          node.to_s
+        else
+          T.must(@source[node.location.start_char...node.location.end_char])
+        end
+      end
+
+      sig { params(node: SyntaxTree::Node).returns(Location) }
+      def node_location(node)
+        Location.from_syntax_tree(@path, node.location)
+      end
+
+      sig { params(node: SyntaxTree::Node).returns(String) }
+      def symbol_string(node)
+        node_string(node).delete_prefix(":")
+      end
+
+      sig do
+        params(
+          node: T.any(SyntaxTree::Args, SyntaxTree::ArgParen, SyntaxTree::ArgsForward, NilClass),
+        ).returns(T::Array[SyntaxTree::Node])
+      end
+      def call_args(node)
+        case node
+        when SyntaxTree::ArgParen
+          call_args(node.arguments)
+        when SyntaxTree::Args
+          node.parts
+        else
+          []
+        end
+      end
+    end
+  end
+end

data/lib/spoom/deadcode/location.rb

@@ -0,0 +1,58 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Spoom
+  module Deadcode
+    class Location
+      extend T::Sig
+
+      include Comparable
+
+      class LocationError < Spoom::Error; end
+
+      class << self
+        extend T::Sig
+
+        sig { params(file: String, location: SyntaxTree::Location).returns(Location) }
+        def from_syntax_tree(file, location)
+          new(file, location.start_line, location.start_column, location.end_line, location.end_column)
+        end
+      end
+
+      sig { returns(String) }
+      attr_reader :file
+
+      sig { returns(Integer) }
+      attr_reader :start_line, :start_column, :end_line, :end_column
+
+      sig do
+        params(
+          file: String,
+          start_line: Integer,
+          start_column: Integer,
+          end_line: Integer,
+          end_column: Integer,
+        ).void
+      end
+      def initialize(file, start_line, start_column, end_line, end_column)
+        @file = file
+        @start_line = start_line
+        @start_column = start_column
+        @end_line = end_line
+        @end_column = end_column
+      end
+
+      sig { override.params(other: BasicObject).returns(T.nilable(Integer)) }
+      def <=>(other)
+        return nil unless Location === other
+
+        to_s <=> other.to_s
+      end
+
+      sig { returns(String) }
+      def to_s
+        "#{@file}:#{@start_line}:#{@start_column}-#{@end_line}:#{@end_column}"
+      end
+    end
+  end
+end

data/lib/spoom/deadcode/reference.rb

@@ -0,0 +1,34 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Spoom
+  module Deadcode
+    # A reference is a call to a method or a constant
+    class Reference < T::Struct
+      extend T::Sig
+
+      class Kind < T::Enum
+        enums do
+          Constant = new
+          Method = new
+        end
+      end
+
+      const :kind, Kind
+      const :name, String
+      const :location, Location
+
+      # Kind
+
+      sig { returns(T::Boolean) }
+      def constant?
+        kind == Kind::Constant
+      end
+
+      sig { returns(T::Boolean) }
+      def method?
+        kind == Kind::Method
+      end
+    end
+  end
+end

data/lib/spoom/deadcode/send.rb

@@ -0,0 +1,18 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Spoom
+  module Deadcode
+    # An abstraction to simplify handling of SyntaxTree::CallNode, SyntaxTree::Command, SyntaxTree::CommandCall and
+    # SyntaxTree::VCall nodes.
+    class Send < T::Struct
+      extend T::Sig
+
+      const :node, SyntaxTree::Node
+      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
+    end
+  end
+end

data/lib/spoom/deadcode.rb

@@ -0,0 +1,55 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "erubi"
+require "syntax_tree"
+
+require_relative "deadcode/erb"
+require_relative "deadcode/index"
+require_relative "deadcode/indexer"
+
+require_relative "deadcode/location"
+require_relative "deadcode/definition"
+require_relative "deadcode/reference"
+require_relative "deadcode/send"
+
+module Spoom
+  module Deadcode
+    class Error < Spoom::Error
+      extend T::Sig
+      extend T::Helpers
+
+      abstract!
+
+      sig { params(message: String, parent: Exception).void }
+      def initialize(message, parent:)
+        super(message)
+        set_backtrace(parent.backtrace)
+      end
+    end
+
+    class ParserError < Error; end
+    class IndexerError < Error; end
+
+    class << self
+      extend T::Sig
+
+      sig { params(index: Index, ruby: String, file: String).void }
+      def index_ruby(index, ruby, file:)
+        node = SyntaxTree.parse(ruby)
+        visitor = Spoom::Deadcode::Indexer.new(file, ruby, index)
+        visitor.visit(node)
+      rescue SyntaxTree::Parser::ParseError => e
+        raise ParserError.new("Error while parsing #{file} (#{e.message} at #{e.lineno}:#{e.column})", parent: e)
+      rescue => e
+        raise IndexerError.new("Error while indexing #{file} (#{e.message})", parent: e)
+      end
+
+      sig { params(index: Index, erb: String, file: String).void }
+      def index_erb(index, erb, file:)
+        ruby = ERB.new(erb).src
+        index_ruby(index, ruby, file: file)
+      end
+    end
+  end
+end