hone 0.1.0

data/lib/hone/patterns/dynamic_ivar.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Hone
+  module Patterns
+    # Pattern: instance_variable_set("@#{name}", value)
+    #
+    # Dynamic instance variable creation causes object shape transitions.
+    # YJIT optimizes based on stable object shapes - when shapes change,
+    # it must deoptimize. Use a Hash for dynamic data instead.
+    #
+    # Impact: Significant with YJIT, none without
+    class DynamicIvar < Base
+      self.pattern_id = :dynamic_ivar
+      self.optimization_type = :jit
+
+      def visit_call_node(node)
+        super
+
+        return unless node.name == :instance_variable_set
+
+        first_arg = node.arguments&.arguments&.first
+        return unless first_arg
+        return unless dynamic_ivar_name?(first_arg)
+
+        add_finding(
+          node,
+          message: "Dynamic instance_variable_set causes object shape transitions, hurting YJIT. Use a Hash for dynamic data instead.",
+          speedup: "Enables better YJIT optimization"
+        )
+      end
+
+      private
+
+      def dynamic_ivar_name?(node)
+        # Interpolated string like "@#{name}"
+        node.is_a?(Prism::InterpolatedStringNode) ||
+          # String concatenation
+          (node.is_a?(Prism::CallNode) && node.name == :+) ||
+          # Variable (not a literal symbol/string)
+          node.is_a?(Prism::LocalVariableReadNode)
+      end
+    end
+  end
+end

data/lib/hone/patterns/dynamic_ivar_get.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Hone
+  module Patterns
+    # Pattern: instance_variable_get("@#{name}")
+    #
+    # Often paired with dynamic instance_variable_set. Suggests the code
+    # is using ivars as a dynamic key-value store, which hurts JIT.
+    #
+    # Impact: Significant with YJIT, none without
+    class DynamicIvarGet < Base
+      self.pattern_id = :dynamic_ivar_get
+      self.optimization_type = :jit
+
+      def visit_call_node(node)
+        super
+
+        return unless node.name == :instance_variable_get
+
+        first_arg = node.arguments&.arguments&.first
+        return unless first_arg
+        return unless first_arg.is_a?(Prism::InterpolatedStringNode) ||
+          first_arg.is_a?(Prism::LocalVariableReadNode)
+
+        add_finding(
+          node,
+          message: "Dynamic instance_variable_get suggests ivars used as key-value store. Use a Hash instead for better YJIT performance.",
+          speedup: "Significant with YJIT, none without"
+        )
+      end
+    end
+  end
+end

data/lib/hone/patterns/each_with_index.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require "set"
+
+module Hone
+  module Patterns
+    # Pattern: array.each_with_index { |item, i| ... } when index or element unused
+    #
+    # When using each_with_index but only using the element (not the index),
+    # use plain .each instead to avoid index tracking overhead.
+    #
+    # When using each_with_index but only using the index (not the element),
+    # use array.size.times { |i| ... } instead for clarity and efficiency.
+    #
+    # Examples:
+    #   # Bad: index `i` is never used
+    #   array.each_with_index { |item, i| puts item }
+    #   # Good: use plain each
+    #   array.each { |item| puts item }
+    #
+    #   # Bad: element `item` is never used
+    #   array.each_with_index { |item, i| puts i }
+    #   # Good: use times
+    #   array.size.times { |i| puts i }
+    class EachWithIndex < Base
+      self.pattern_id = :each_with_index
+      self.optimization_type = :cpu
+
+      def visit_call_node(node)
+        super
+        return unless node.name == :each_with_index && node.block.is_a?(Prism::BlockNode)
+
+        check_block_parameter_usage(node)
+      end
+
+      private
+
+      def check_block_parameter_usage(node)
+        block = node.block
+        parameters = block.parameters
+
+        # If no parameters or not the expected structure, skip
+        return unless parameters.is_a?(Prism::BlockParametersNode)
+        return unless parameters.parameters.is_a?(Prism::ParametersNode)
+
+        params = parameters.parameters
+        requireds = params.requireds
+
+        # We expect two required parameters for each_with_index: |element, index|
+        return unless requireds.size == 2
+
+        element_param = requireds[0]
+        index_param = requireds[1]
+
+        # Get parameter names
+        element_name = extract_param_name(element_param)
+        index_name = extract_param_name(index_param)
+
+        return unless element_name && index_name
+
+        # Collect all local variable reads in the block body
+        used_locals = collect_local_variable_reads(block.body)
+
+        element_used = used_locals.include?(element_name)
+        index_used = used_locals.include?(index_name)
+
+        if !index_used && element_used
+          add_finding(
+            node,
+            message: "Index parameter `#{index_name}` is not used. Use `.each` instead of `.each_with_index` to avoid index tracking overhead.",
+            speedup: "Minor, avoids index tracking overhead"
+          )
+        elsif !element_used && index_used
+          add_finding(
+            node,
+            message: "Element parameter `#{element_name}` is not used. Consider using `.size.times { |#{index_name}| }` instead of `.each_with_index` for clarity.",
+            speedup: "Minor, avoids index tracking overhead"
+          )
+        elsif !element_used && !index_used
+          add_finding(
+            node,
+            message: "Neither element nor index parameters are used. Consider using `.size.times` or `.each` depending on intent.",
+            speedup: "Minor, avoids index tracking overhead"
+          )
+        end
+      end
+
+      def extract_param_name(param)
+        case param
+        when Prism::RequiredParameterNode
+          param.name
+        end
+      end
+
+      def collect_local_variable_reads(node)
+        collector = LocalVariableCollector.new
+        node&.accept(collector)
+        collector.used_names
+      end
+
+      # Helper visitor to collect all local variable read references
+      class LocalVariableCollector < Prism::Visitor
+        attr_reader :used_names
+
+        def initialize
+          @used_names = Set.new
+        end
+
+        def visit_local_variable_read_node(node)
+          @used_names << node.name
+          super
+        end
+      end
+    end
+  end
+end

data/lib/hone/patterns/each_with_object.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Hone
+  module Patterns
+    # Pattern: inject({}) { |acc, x| ... ; acc } -> each_with_object({}) { |x, acc| }
+    #
+    # inject/reduce with a hash or array accumulator requires returning the
+    # accumulator at the end of each block iteration. each_with_object
+    # automatically passes the same object, making the code cleaner and
+    # avoiding the need to return the accumulator.
+    #
+    # Examples:
+    #   # Bad: must return acc at end of block
+    #   items.inject({}) { |acc, x| acc[x.id] = x; acc }
+    #   # Good: acc is automatically passed
+    #   items.each_with_object({}) { |x, acc| acc[x.id] = x }
+    class EachWithObject < Base
+      self.pattern_id = :each_with_object
+      self.optimization_type = :allocation
+
+      def visit_call_node(node)
+        super
+
+        return unless %i[inject reduce].include?(node.name)
+        return unless block_attached?(node)
+        return unless empty_collection_initial_value?(node)
+
+        add_finding(
+          node,
+          message: "Consider using `.each_with_object(#{initial_value_literal(node)})` instead of `.#{node.name}(#{initial_value_literal(node)})` for cleaner accumulator pattern",
+          speedup: "Cleaner, avoids returning accumulator each iteration"
+        )
+      end
+
+      private
+
+      def empty_collection_initial_value?(node)
+        args = node.arguments&.arguments
+        return false unless args&.size == 1
+
+        arg = args.first
+        empty_hash?(arg) || empty_array?(arg)
+      end
+
+      def empty_hash?(arg)
+        arg.is_a?(Prism::HashNode) && arg.elements.empty?
+      end
+
+      def empty_array?(arg)
+        arg.is_a?(Prism::ArrayNode) && arg.elements.empty?
+      end
+
+      def initial_value_literal(node)
+        arg = node.arguments.arguments.first
+        if arg.is_a?(Prism::HashNode)
+          "{}"
+        else
+          "[]"
+        end
+      end
+    end
+  end
+end

data/lib/hone/patterns/flatten_once.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Hone
+  module Patterns
+    # Pattern: array.flatten -> consider array.flatten(1)
+    #
+    # flatten without an argument flattens all levels recursively.
+    # If you only need one level, flatten(1) is faster.
+    class FlattenOnce < Base
+      self.pattern_id = :flatten_once
+      self.optimization_type = :cpu
+
+      def visit_call_node(node)
+        super
+
+        # Look for: .flatten without arguments
+        return unless node.name == :flatten
+        return unless node.arguments.nil?
+
+        add_finding(
+          node,
+          message: "Consider `.flatten(1)` if only one level of flattening is needed",
+          speedup: "Faster when you only need one level"
+        )
+      end
+    end
+  end
+end

data/lib/hone/patterns/gsub_to_tr.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Hone
+  module Patterns
+    # Pattern: str.gsub('a', 'b') -> str.tr('a', 'b')
+    #
+    # For replacing single characters, tr is optimized and faster than gsub.
+    # gsub has regex overhead even for simple string patterns.
+    class GsubToTr < Base
+      self.pattern_id = :gsub_to_tr
+      self.optimization_type = :cpu
+
+      def visit_call_node(node)
+        super
+
+        return unless node.name == :gsub
+
+        args = node.arguments&.arguments
+        return unless args&.size == 2
+
+        first_arg = args[0]
+        second_arg = args[1]
+
+        # Check if both arguments are single-character strings
+        return unless single_char_string?(first_arg) && single_char_string?(second_arg)
+
+        add_finding(
+          node,
+          message: "Use `.tr('#{string_value(first_arg)}', '#{string_value(second_arg)}')` instead of `.gsub` for single character replacement",
+          speedup: "tr is optimized for character translation, avoids regex overhead"
+        )
+      end
+
+      private
+
+      def single_char_string?(node)
+        return false unless node.is_a?(Prism::StringNode)
+
+        content = node.content
+        content.is_a?(String) && content.length == 1
+      end
+
+      def string_value(node)
+        node.content
+      end
+    end
+  end
+end

data/lib/hone/patterns/hash_each_key.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Hone
+  module Patterns
+    # Pattern: hash.keys.each { } -> hash.each_key { }
+    #
+    # keys.each creates an intermediate array of keys then iterates.
+    # each_key iterates keys directly without allocation.
+    #
+    # Also detects hash.values.each { } -> hash.each_value { }
+    class HashEachKey < Base
+      self.pattern_id = :hash_each_key
+      self.optimization_type = :allocation
+
+      def visit_call_node(node)
+        super
+
+        # Look for: .each { } where receiver is .keys or .values
+        return unless node.name == :each && block_attached?(node)
+
+        receiver = node.receiver
+        return unless receiver.is_a?(Prism::CallNode)
+
+        case receiver.name
+        when :keys
+          add_finding(
+            node,
+            message: "Use `.each_key { }` instead of `.keys.each { }` to avoid intermediate array",
+            speedup: "Iterates keys directly without allocating array"
+          )
+        when :values
+          add_finding(
+            node,
+            message: "Use `.each_value { }` instead of `.values.each { }` to avoid intermediate array",
+            speedup: "Iterates values directly without allocating array"
+          )
+        end
+      end
+    end
+  end
+end

data/lib/hone/patterns/hash_each_value.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Hone
+  module Patterns
+    # Pattern: hash.values.each { } -> hash.each_value { }
+    #
+    # values.each creates an intermediate array of values then iterates.
+    # each_value iterates values directly without allocation.
+    class HashEachValue < Base
+      self.pattern_id = :hash_each_value
+      self.optimization_type = :allocation
+
+      def visit_call_node(node)
+        super
+
+        # Look for: .each { } where receiver is .values
+        return unless node.name == :each && block_attached?(node)
+
+        receiver = node.receiver
+        return unless receiver.is_a?(Prism::CallNode)
+        return unless receiver.name == :values
+
+        add_finding(
+          node,
+          message: "Use `.each_value { }` instead of `.values.each { }` to avoid intermediate array",
+          speedup: "Avoids creating intermediate array of values"
+        )
+      end
+    end
+  end
+end

data/lib/hone/patterns/hash_keys_include.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Hone
+  module Patterns
+    # Pattern: hash.keys.include?(key) -> hash.key?(key)
+    #
+    # keys.include? creates an array of all keys then searches it (O(n)).
+    # key? does a direct hash lookup (O(1)).
+    class HashKeysInclude < Base
+      self.pattern_id = :hash_keys_include
+      self.optimization_type = :allocation
+
+      def visit_call_node(node)
+        super
+
+        # Look for: .include?(x) where receiver is .keys
+        return unless node.name == :include? && node.arguments&.arguments&.size == 1
+
+        receiver = node.receiver
+        return unless receiver.is_a?(Prism::CallNode) && receiver.name == :keys
+
+        add_finding(
+          node,
+          message: "Use `.key?(k)` instead of `.keys.include?(k)` for O(1) lookup without array allocation",
+          speedup: "O(n) to O(1), avoids allocating array of all keys"
+        )
+      end
+    end
+  end
+end

data/lib/hone/patterns/hash_merge_bang.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Hone
+  module Patterns
+    # Pattern: hash = hash.merge(other) -> hash.merge!(other)
+    #
+    # Reassigning to the same variable after merge creates a new hash.
+    # merge! mutates in place, avoiding allocation.
+    class HashMergeBang < Base
+      self.pattern_id = :hash_merge_bang
+      self.optimization_type = :allocation
+
+      def visit_local_variable_write_node(node)
+        super
+
+        # Look for: x = x.merge(...)
+        value = node.value
+        return unless value.is_a?(Prism::CallNode)
+        return unless value.name == :merge
+
+        receiver = value.receiver
+        return unless receiver.is_a?(Prism::LocalVariableReadNode)
+        return unless receiver.name == node.name
+
+        add_finding(
+          node,
+          message: "Use `.merge!` instead of `#{node.name} = #{node.name}.merge(...)` to avoid creating new hash",
+          speedup: "Avoids creating new hash, mutates in place"
+        )
+      end
+    end
+  end
+end

data/lib/hone/patterns/hash_values_include.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Hone
+  module Patterns
+    # Pattern: hash.values.include?(x) -> hash.value?(x)
+    #
+    # values.include? creates an intermediate array of values then searches.
+    # value? checks directly without allocation.
+    class HashValuesInclude < Base
+      self.pattern_id = :hash_values_include
+      self.optimization_type = :allocation
+
+      def visit_call_node(node)
+        super
+
+        # Look for: .include?(arg) where receiver is .values
+        return unless node.name == :include? && node.arguments&.arguments&.size == 1
+
+        receiver = node.receiver
+        return unless receiver.is_a?(Prism::CallNode)
+        return unless receiver.name == :values
+
+        add_finding(
+          node,
+          message: "Use `.value?(x)` instead of `.values.include?(x)` to avoid intermediate array",
+          speedup: "Avoids creating intermediate array of values"
+        )
+      end
+    end
+  end
+end

data/lib/hone/patterns/inject_sum.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Hone
+  module Patterns
+    # Pattern: array.inject(0, :+) -> array.sum
+    #
+    # sum is optimized for numeric summation with native implementation.
+    # Also handles empty arrays correctly (returns 0).
+    class InjectSum < Base
+      self.pattern_id = :inject_sum
+      self.optimization_type = :cpu
+
+      def visit_call_node(node)
+        super
+
+        return unless %i[inject reduce].include?(node.name)
+        return unless sum_pattern?(node)
+
+        add_finding(
+          node,
+          message: "Use `.sum` instead of `.#{node.name}(:+)` for optimized numeric summation",
+          speedup: "Native C implementation, cleaner code"
+        )
+      end
+
+      private
+
+      def sum_pattern?(node)
+        args = node.arguments&.arguments
+        return false unless args
+
+        # Pattern 1: inject(:+) or reduce(:+)
+        if args.size == 1
+          arg = args.first
+          return true if arg.is_a?(Prism::SymbolNode) && arg.value == "+"
+        end
+
+        # Pattern 2: inject(0, :+) or reduce(0, :+)
+        if args.size == 2
+          second_arg = args[1]
+          return true if second_arg.is_a?(Prism::SymbolNode) && second_arg.value == "+"
+        end
+
+        false
+      end
+    end
+  end
+end

data/lib/hone/patterns/kernel_loop.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Hone
+  module Patterns
+    # Pattern: Kernel#loop { break if ... } -> while true ... end
+    #
+    # Kernel#loop has method call overhead vs the while construct.
+    #
+    # From sqids-ruby commit 8a74142
+    class KernelLoop < Base
+      self.pattern_id = :kernel_loop
+      self.optimization_type = :cpu
+
+      def visit_call_node(node)
+        super
+        # Look for: loop { ... } (implicit receiver, block present)
+        return unless node.name == :loop && node.receiver.nil? && node.block.is_a?(Prism::BlockNode)
+
+        add_finding(
+          node,
+          message: "Use `while true ... end` instead of `loop { }` in hot paths to avoid method call overhead",
+          speedup: "Minor, but adds up in tight loops"
+        )
+      end
+    end
+  end
+end

data/lib/hone/patterns/lazy_ivar.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Hone
+  module Patterns
+    # Pattern: @ivar ||= value (outside initialize)
+    #
+    # When an ivar is first assigned outside initialize, it changes the
+    # object's shape at runtime. YJIT prefers stable shapes from creation.
+    #
+    # This pattern detects ||= with ivars outside of initialize methods.
+    #
+    # Impact: Moderate with YJIT, none without
+    class LazyIvar < Base
+      self.pattern_id = :lazy_ivar
+      self.optimization_type = :jit
+
+      def initialize(file_path)
+        super
+        @in_initialize = false
+      end
+
+      def visit_def_node(node)
+        with_context(:@in_initialize, node.name == :initialize) { super }
+      end
+
+      def visit_instance_variable_or_write_node(node)
+        super
+        # @ivar ||= value pattern
+        return if @in_initialize
+
+        add_finding(
+          node,
+          message: "Lazy ivar initialization (||=) outside initialize causes shape transitions. Define #{node.name} = nil in initialize for better YJIT.",
+          speedup: "Moderate with YJIT, none without"
+        )
+      end
+    end
+  end
+end

data/lib/hone/patterns/map_compact.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Hone
+  module Patterns
+    # Pattern: array.map { }.compact -> array.filter_map { }
+    #
+    # map.compact creates an intermediate array from map that may contain nils,
+    # then compacts it. filter_map combines both operations avoiding the
+    # intermediate allocation.
+    class MapCompact < Base
+      self.pattern_id = :map_compact
+      self.optimization_type = :allocation
+
+      def visit_call_node(node)
+        super
+
+        # Look for: .compact where receiver is .map with a block
+        return unless node.name == :compact
+
+        receiver = node.receiver
+        return unless receiver.is_a?(Prism::CallNode)
+        return unless receiver.name == :map && block_attached?(receiver)
+
+        add_finding(
+          node,
+          message: "Use `.filter_map { }` instead of `.map { }.compact` to avoid intermediate array with nils",
+          speedup: "Avoids intermediate array with nils"
+        )
+      end
+    end
+  end
+end

data/lib/hone/patterns/map_flatten.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Hone
+  module Patterns
+    # Pattern: array.map { }.flatten -> array.flat_map { }
+    #
+    # map.flatten creates an intermediate array from map, then flattens it.
+    # flat_map combines both operations avoiding the intermediate allocation.
+    class MapFlatten < Base
+      self.pattern_id = :map_flatten
+      self.optimization_type = :allocation
+
+      def visit_call_node(node)
+        super
+
+        # Look for: .flatten where receiver is .map with a block
+        return unless node.name == :flatten
+
+        receiver = node.receiver
+        return unless receiver.is_a?(Prism::CallNode)
+        return unless receiver.name == :map && block_attached?(receiver)
+
+        add_finding(
+          node,
+          message: "Use `.flat_map { }` instead of `.map { }.flatten` to avoid intermediate array",
+          speedup: "Single pass, no intermediate allocation"
+        )
+      end
+    end
+  end
+end