ryac 0.2.0

data/lib/ryac/pipeline/rename_patcher.rb

@@ -0,0 +1,274 @@
+# frozen_string_literal: true
+
+module Ryac
+  module Pipeline
+    # Shared infrastructure for L2-L5 rename pipeline stages.
+    # Each stage includes this module and implements its own collect_patches.
+    module RenamePatcher
+      private
+
+      def walk_prism(node, &block)
+        return unless node
+        result = yield node
+        return if result == :skip_children
+
+        children = node.compact_child_nodes
+        if node.is_a?(Prism::MatchWriteNode)
+          children = children.reject { |c| c.is_a?(Prism::LocalVariableTargetNode) }
+        end
+        children.each { |child| walk_prism(child, &block) }
+      end
+
+      # Same key the analysis stored the rename under. Kept as its own name
+      # because the patchers only ever pass Prism nodes, but it must not grow a
+      # second implementation — the two sides sharing one definition is the
+      # point.
+      def prism_location_key(node)
+        AstUtils.location_key(node)
+      end
+
+      def patch_variable(node, patches, rename_map)
+        key = prism_location_key(node)
+        short = rename_map[key]
+        return unless short
+
+        loc = node.location
+        patches << { start: loc.start_offset, end: loc.end_offset, replacement: short }
+      end
+
+      def patch_variable_name_only(node, patches, rename_map)
+        key = prism_location_key(node)
+        short = rename_map[key]
+        return unless short
+
+        name_loc = node.name_loc
+        patches << { start: name_loc.start_offset, end: name_loc.end_offset, replacement: short }
+      end
+
+      def patch_def_params(node, patches, analysis, param_names_key)
+        return unless node.parameters
+
+        syntax_key = AstUtils.line_col_key(node)
+        data = analysis.syntax_data[syntax_key]
+        return unless data
+
+        # any? rather than empty?: `empty?` on a receiver TypeProf can prove
+        # is a Hash gets rewritten to `=={}` — but only when it can prove it,
+        # and whether it can differs between the original and the minified
+        # text. Self-hosting then never reaches a fixed point. `any?` has no
+        # such rewrite.
+        param_names = data[param_names_key] || {} #: Hash[Symbol, String]
+        return unless param_names.any?
+
+        params = node.parameters
+        patch_required_params(params.requireds, param_names, patches)
+        patch_optional_params(params.optionals, param_names, patches)
+        patch_rest_param(params.rest, param_names, patches)
+        patch_post_params(params.posts, param_names, patches)
+        patch_keyword_params(params.keywords, param_names, patches)
+        patch_keyword_rest(params.keyword_rest, param_names, patches)
+        patch_block_param_node(params.block, param_names, patches)
+      end
+
+      def patch_required_params(requireds, param_names, patches)
+        return unless requireds
+        requireds.each do |p|
+          if p.is_a?(Prism::MultiTargetNode)
+            patch_multi_target_params(p, param_names, patches)
+          elsif p.is_a?(Prism::RequiredParameterNode)
+            short = param_names[p.name]
+            next unless short && short != p.name.to_s
+            patches << { start: p.location.start_offset, end: p.location.end_offset, replacement: short }
+          end
+        end
+      end
+
+      def patch_multi_target_params(node, param_names, patches)
+        node.lefts.each do |p|
+          if p.is_a?(Prism::RequiredParameterNode)
+            short = param_names[p.name]
+            next unless short && short != p.name.to_s
+            patches << { start: p.location.start_offset, end: p.location.end_offset, replacement: short }
+          elsif p.is_a?(Prism::MultiTargetNode)
+            patch_multi_target_params(p, param_names, patches)
+          end
+        end
+        if node.rest.is_a?(Prism::SplatNode) &&
+           node.rest.expression.is_a?(Prism::RequiredParameterNode)
+          p = node.rest.expression
+          short = param_names[p.name]
+          if short && short != p.name.to_s
+            patches << { start: p.location.start_offset, end: p.location.end_offset, replacement: short }
+          end
+        end
+      end
+
+      def patch_optional_params(optionals, param_names, patches)
+        return unless optionals
+        optionals.each do |p|
+          short = param_names[p.name]
+          next unless short && short != p.name.to_s
+          patches << { start: p.name_loc.start_offset, end: p.name_loc.end_offset, replacement: short }
+        end
+      end
+
+      # Shared tail of the rest/**rest/&block patchers: Prism types their
+      # name_loc as nullable, but a named parameter always carries one.
+      def patch_named_param(name, name_loc, param_names, patches)
+        short = param_names[name]
+        return unless name_loc && short && short != name.to_s
+        patches << { start: name_loc.start_offset, end: name_loc.end_offset, replacement: short }
+      end
+
+      def patch_rest_param(rest, param_names, patches)
+        return unless rest.is_a?(Prism::RestParameterNode) && rest.name
+        patch_named_param(rest.name, rest.name_loc, param_names, patches)
+      end
+
+      def patch_post_params(posts, param_names, patches)
+        return unless posts
+        posts.each do |p|
+          next unless p.is_a?(Prism::RequiredParameterNode)
+          short = param_names[p.name]
+          next unless short && short != p.name.to_s
+          patches << { start: p.location.start_offset, end: p.location.end_offset, replacement: short }
+        end
+      end
+
+      def patch_keyword_params(keywords, param_names, patches)
+        return unless keywords
+        keywords.each do |p|
+          short = param_names[p.name]
+          next unless short && short != p.name.to_s
+          patches << { start: p.name_loc.start_offset, end: p.name_loc.end_offset, replacement: "#{short}:" }
+        end
+      end
+
+      def patch_keyword_rest(keyword_rest, param_names, patches)
+        return unless keyword_rest.is_a?(Prism::KeywordRestParameterNode) && keyword_rest.name
+        patch_named_param(keyword_rest.name, keyword_rest.name_loc, param_names, patches)
+      end
+
+      def patch_block_param_node(block, param_names, patches)
+        return unless block.is_a?(Prism::BlockParameterNode) && block.name
+        patch_named_param(block.name, block.name_loc, param_names, patches)
+      end
+
+      def patch_block_params(node, patches, block_param_names_map)
+        return unless node.block.is_a?(Prism::BlockNode)
+        block = node.block
+        return unless block.parameters.is_a?(Prism::BlockParametersNode)
+
+        key = prism_location_key(node)
+        param_map = block_param_names_map[key]
+        return unless param_map
+
+        mangled_values = param_map.values
+        block_params = block.parameters.parameters
+        has_non_required = block_params && (
+          block_params.optionals&.any? ||
+          block_params.rest ||
+          block_params.posts&.any? ||
+          block_params.keywords&.any? ||
+          block_params.keyword_rest ||
+          block_params.block
+        )
+        if mangled_values.any? { |v| v.match?(/^_\d+$/) } && !has_non_required
+          bp_loc = block.parameters.location
+          patches << { start: bp_loc.start_offset, end: bp_loc.end_offset, replacement: '' }
+          return
+        end
+
+        block_params = block.parameters.parameters
+        return unless block_params
+
+        patch_required_params(block_params.requireds, param_map, patches)
+        patch_optional_params(block_params.optionals, param_map, patches)
+        patch_rest_param(block_params.rest, param_map, patches)
+        patch_post_params(block_params.posts, param_map, patches)
+        patch_keyword_params(block_params.keywords, param_map, patches)
+        patch_keyword_rest(block_params.keyword_rest, param_map, patches)
+        patch_block_param_node(block_params.block, param_map, patches)
+      end
+
+      def patch_for_node(node, patches, analysis, mangled_key)
+        syntax_key = AstUtils.line_col_key(node)
+        data = analysis.syntax_data[syntax_key]
+        return unless data
+
+        target_name = data[mangled_key] #: String?
+        return unless target_name
+
+        idx = node.index
+        return unless idx.is_a?(Prism::LocalVariableTargetNode)
+        patches << { start: idx.location.start_offset, end: idx.location.end_offset, replacement: target_name }
+      end
+
+      def patch_assoc(node, patches, rename_map, keyword_arg: false)
+        key_node = node.key
+        val_node = node.value
+
+        return unless key_node.is_a?(Prism::SymbolNode)
+        return unless key_node.value.to_s.match?(/\A[a-zA-Z_][a-zA-Z0-9_]*\z/)
+
+        original_key = key_node.value.to_s
+        renamed_key = rename_map[prism_location_key(key_node)]
+
+        if val_node.is_a?(Prism::ImplicitNode)
+          inner = val_node.value
+          if inner.is_a?(Prism::LocalVariableReadNode)
+            mangled_var = rename_map[prism_location_key(inner)] || inner.name.to_s
+            key_name = keyword_arg ? (renamed_key || original_key) : original_key
+            if key_name == mangled_var
+              if key_name != original_key
+                patches << { start: key_node.location.start_offset, end: val_node.location.end_offset,
+                             replacement: "#{key_name}:" }
+              end
+            else
+              sep = mangled_var.start_with?(':') ? ': ' : ':'
+              patches << { start: key_node.location.start_offset, end: val_node.location.end_offset,
+                           replacement: "#{key_name}#{sep}#{mangled_var}" }
+            end
+          else
+            if keyword_arg && renamed_key
+              patches << { start: key_node.location.start_offset, end: val_node.location.end_offset,
+                           replacement: "#{renamed_key}:" }
+            end
+          end
+          return :skip_children
+        end
+
+        key_name = renamed_key || original_key
+
+        if val_node.is_a?(Prism::LocalVariableReadNode)
+          mangled_var = rename_map[prism_location_key(val_node)] || val_node.name.to_s
+          if key_name == mangled_var
+            patches << { start: key_node.location.start_offset, end: val_node.location.end_offset,
+                         replacement: "#{key_name}:" }
+            return :skip_children
+          end
+        end
+
+        if renamed_key
+          loc = key_node.location
+          suffix = loc.slice.end_with?(':') ? ':' : ''
+          patches << { start: loc.start_offset, end: loc.end_offset, replacement: "#{renamed_key}#{suffix}" }
+        end
+      end
+
+      def patch_keyword_hash(node, patches, rename_map, &block)
+        node.elements.each do |elem|
+          if elem.is_a?(Prism::AssocNode)
+            result = patch_assoc(elem, patches, rename_map, keyword_arg: true)
+            if result != :skip_children
+              elem.compact_child_nodes.each { |child| walk_prism(child, &block) }
+            end
+          else
+            walk_prism(elem, &block)
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/ryac/pipeline/source_patcher.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Ryac
+  module Pipeline
+    module SourcePatcher
+      private
+
+      def mk(node, replacement)
+        { start: node.location.start_offset, end: node.location.end_offset, replacement: replacement }
+      end
+
+      # The one patch applier: every stage splices byte patches through
+      # here. Patches must be disjoint — an overlap means two rewrites
+      # fought over the same bytes, and applying either order silently
+      # corrupts the output, so it raises with both patches named. The
+      # end-position tie-break keeps same-start insertions deterministic.
+      def apply_patches(source, patches)
+        return source if patches.none?
+        sorted = patches.sort_by { |p| [-p[:start], -p[:end]] }
+        sorted.each_cons(2) do |after, before|
+          # each_cons(2) yields only full pairs; the destructuring alone is
+          # what makes the elements look nilable.
+          # @type var after: { start: Integer, end: Integer, replacement: String }
+          # @type var before: { start: Integer, end: Integer, replacement: String }
+          if before[:end] > after[:start]
+            raise MinifyError, "overlapping patches: #{before.inspect} / #{after.inspect}"
+          end
+        end
+        result = source.b.dup
+        sorted.each do |patch|
+          result[patch[:start]...patch[:end]] = patch[:replacement].b
+        end
+        result.force_encoding(source.encoding)
+      end
+
+      # byteslice is typed String? but node offsets always lie inside the
+      # source the node was parsed from, so the result is never nil.
+      def src(source, node) # steep:ignore MethodBodyTypeMismatch
+        source.byteslice(node.location.start_offset, node.location.length)
+      end
+
+      # The output of every pipeline permutation must at minimum be valid
+      # Ruby. Prism also rejects duplicated parameter names, so a rename that
+      # collides inside a signature is caught here, at the stage that
+      # produced it.
+      def verify_parses(text, label)
+        return if text.empty?
+
+        errors = Prism.parse(text).errors
+        raise InvalidOutputError.new(label, errors) unless errors.empty?
+      end
+    end
+  end
+end

data/lib/ryac/pipeline/spelling_shorten.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Ryac
+  module Pipeline
+    # Same value, shorter spelling: symbol and string array literals collapse
+    # to their percent forms when that is strictly smaller, and the English
+    # spellings of Ruby's special globals collapse to their punctuation
+    # forms — the same storage cell under either name. The pairing lives in
+    # GvarRenameMapping::PERL_SPELLINGS, which also shields both spellings
+    # from the gvar renamer.
+    class SpellingShorten < Stage
+      # Words a percent literal can carry verbatim: nothing that needs
+      # escaping and nothing that could close or balance the delimiter.
+      SAFE_WORD = %r{\A[A-Za-z0-9_/.:=!?-]+\z}
+
+      def collect(ctx, patches)
+        AstUtils.each_node(ctx.ast) do |node|
+          case node
+          when Prism::ArrayNode
+            try_percent_array(node, patches)
+          when Prism::GlobalVariableReadNode, Prism::GlobalVariableWriteNode
+            short = GvarRenameMapping::PERL_SPELLINGS[node.name]
+            if short
+              loc = node.is_a?(Prism::GlobalVariableWriteNode) ? node.name_loc : node.location
+              patches << { start: loc.start_offset, end: loc.end_offset, replacement: short }
+            end
+          end
+        end
+      end
+
+      private
+
+      def try_percent_array(node, patches)
+        return unless node.opening == '['
+
+        elements = node.elements
+        return if elements.empty?
+
+        sigil = if elements.all? { |e| plain?(e, Prism::SymbolNode) }
+                  '%i'
+                elsif elements.all? { |e| plain?(e, Prism::StringNode) }
+                  '%w'
+                end
+        return unless sigil
+
+        # Both node types carry their text as unescaped; SAFE_WORD already
+        # guaranteed the text survives a percent literal verbatim.
+        words = elements.map { |e| e.unescaped } # steep:ignore NoMethod
+        new_size = 4 + words.sum(&:bytesize) + words.size - 1
+        return unless new_size < node.location.length
+
+        patches << mk(node, "#{sigil}[#{words.join(' ')}]")
+      end
+
+      def plain?(node, klass)
+        node.is_a?(klass) && SAFE_WORD.match?(node.unescaped) # steep:ignore NoMethod
+      end
+    end
+  end
+end

data/lib/ryac/pipeline/stage.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+# Stage#call applies patches at load-definition time via SourcePatcher —
+# the module must be concatenated in front of this file.
+require_relative 'source_patcher'
+
+module Ryac
+  module Pipeline
+    # Everything a stage sees while collecting: the current text, its parse,
+    # and — inside an analysis batch — the one AnalysisResult. aliases and
+    # preamble accumulate finish contributions in list order.
+    StageContext = Struct.new(:source, :ast, :analysis, :aliases, :preamble)
+
+    # The one stage contract.
+    #
+    # A stage declares what it needs (needs_analysis?), whether it must be
+    # re-run to a fixed point (fixpoint?), collects byte patches against the
+    # context, and contributes aliases/preamble in finish. Parsing, patch
+    # application and iteration belong to the runner, never to the stage.
+    class Stage
+      include SourcePatcher
+
+      # true → member of an analysis batch: the runner parses and runs
+      # TypeProf once per maximal run of consecutive analysis stages, and
+      # every member collects against that single AnalysisResult.
+      def needs_analysis? = false
+
+      # true → the runner re-parses and re-collects until no patches remain.
+      def fixpoint? = false
+
+      def collect(ctx, patches)
+        raise NotImplementedError, "#{self.class}#collect must be implemented"
+      end
+
+      # Post-application contribution (aliases/preamble). Stages with
+      # nothing to add do not override this — no identity fakes. Only the
+      # runner collects the contribution; the standalone driver below
+      # returns text alone.
+      def finish(ctx) = nil
+
+      # Driver for a standalone syntactic stage: the per-stage public API.
+      def call(input)
+        if needs_analysis?
+          raise InternalError, "#{self.class} needs analysis; run it through StageRunner"
+        end
+
+        source = input
+        loop do
+          ctx = StageContext.new(source, Prism.parse(source).value, nil, '', '')
+          patches = [] #: Array[patch_entry]
+          collect(ctx, patches)
+          break if patches.none?
+
+          new_source = apply_patches(source, patches)
+          break if fixpoint? && new_source == source
+
+          source = new_source
+          break unless fixpoint?
+        end
+        source
+      end
+
+      private
+
+      # Analysis stages run only inside the runner's batch, which always
+      # supplies the AnalysisResult.
+      def analysis(ctx)
+        ctx.analysis #: AnalysisResult
+      end
+    end
+  end
+end

data/lib/ryac/pipeline/stage_runner.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Ryac
+  module Pipeline
+    # The one place that executes a stage list.
+    #
+    # The list is ordered — phase is position, nothing else. Compaction is
+    # the fixed first step. A maximal run of consecutive needs_analysis?
+    # stages forms the analysis batch: TypeProf runs once for it, every
+    # member collects into one patch pool, the pool is applied in a single
+    # splice, and each member's finish then contributes aliases/preamble in
+    # list order. A list that would need a second batch implies a second
+    # TypeProf run — that is a composition error, and it raises before
+    # running anything half-way.
+    class StageRunner
+      include SourcePatcher
+
+      def initialize(stdlib_requires: [], rbs_files: {})
+        @stdlib_requires = stdlib_requires
+        @rbs_files = rbs_files
+      end
+
+      def call(code, stage_defs)
+        stages = stage_defs.map { |entry| instantiate(entry) }
+
+        batches = stages.chunk_while { |a, b| a.needs_analysis? == b.needs_analysis? }.to_a
+        analysis_batches = batches.count { |chunk| chunk.fetch(0).needs_analysis? }
+        if analysis_batches > 1
+          raise ArgumentError,
+                "stage list needs #{analysis_batches} analysis batches; " \
+                "TypeProf runs once, so all analysis stages must be consecutive"
+        end
+
+        result = Compactor.new.call(code)
+        # The compacted text is the dialect every stage downstream assumes.
+        # If it does not parse, the Compactor is the culprit — name it here
+        # instead of letting whichever stage trips first inherit the blame.
+        verify_parses(result, 'compacted')
+        aliases = ''
+        preamble = ''
+
+        batches.each do |chunk|
+          if chunk.fetch(0).needs_analysis?
+            result, aliases, preamble = run_analysis_batch(result, chunk)
+          else
+            chunk.each { |stage| result = stage.call(result) }
+          end
+        end
+
+        verify_parses(result, 'code')
+        verify_parses(aliases, 'aliases')
+        RenameResult.new(code: result, aliases: aliases, preamble: preamble)
+      end
+
+      private
+
+      def instantiate(entry)
+        klass, kwargs = entry
+        # A stage entry is data ([class] or [class, kwargs]); configuration
+        # becomes constructor state here and nowhere else.
+        kwargs ? klass.new(**kwargs) : klass.new
+      end
+
+      def run_analysis_batch(code, batch)
+        source = ConcatenatedSource.new(
+          content: code,
+          stdlib_requires: @stdlib_requires,
+          rbs_files: @rbs_files
+        )
+        analysis = Analyzer.new.call(source)
+
+        ctx = StageContext.new(code, analysis.prism_ast, analysis, '', '')
+        patches = [] #: Array[patch_entry]
+        batch.each { |stage| stage.collect(ctx, patches) }
+
+        result = apply_patches(code, patches)
+        ctx.source = result
+        batch.each { |stage| stage.finish(ctx) }
+
+        [result, ctx.aliases, ctx.preamble]
+      end
+    end
+  end
+end

data/lib/ryac/pipeline/variable_renamer.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module Ryac
+  module Pipeline
+    # Configurable variable renaming stage.
+    # Default (no features): renames locals only.
+    # features: { keywords: true } → locals + keywords (Level 3)
+    # features: { keywords: true, ivars: true, cvars: true, gvars: true } → all variables (Level 4)
+    class VariableRenamer < Stage
+      include RenamePatcher
+
+      FEATURES = { locals: true, keywords: false, ivars: false, cvars: false, gvars: false }.freeze
+
+      def needs_analysis? = true
+
+      def initialize(features: {})
+        @features = FEATURES.merge(features)
+      end
+
+      def collect(ctx, patches)
+        analysis = analysis(ctx)
+        rename_map = build_rename_map(analysis)
+        block_param_names_map = analysis.block_param_names_map
+        collect_patches(ctx.ast, patches, analysis, rename_map, block_param_names_map)
+      end
+
+      private
+
+      def build_rename_map(analysis)
+        map = {} #: Hash[location_key, String]
+        map.merge!(analysis.local_rename_entries) if @features[:locals]
+        map.merge!(analysis.keyword_rename_entries) if @features[:keywords]
+        if @features[:ivars]
+          map.merge!(analysis.ivar_rename_entries)
+          map.merge!(analysis.attr_ivar_entries) if @features[:attr_ivars]
+        end
+        map.merge!(analysis.cvar_rename_entries) if @features[:cvars]
+        map.merge!(analysis.gvar_rename_entries) if @features[:gvars]
+        map
+      end
+
+      def collect_patches(node, patches, analysis, rename_map, block_param_names_map)
+        callback = proc { |subnode| handle_node(subnode, patches, analysis, rename_map, block_param_names_map) } #: ^(Prism::Node) -> (Symbol | nil)
+        walk_prism(node, &callback)
+      end
+
+      def handle_node(subnode, patches, analysis, rename_map, block_param_names_map)
+        case subnode
+        # Local variables
+        when Prism::LocalVariableReadNode
+          patch_variable(subnode, patches, rename_map)
+        when Prism::LocalVariableWriteNode
+          patch_variable_name_only(subnode, patches, rename_map)
+        when Prism::LocalVariableTargetNode
+          patch_variable(subnode, patches, rename_map)
+        when Prism::LocalVariableOperatorWriteNode,
+             Prism::LocalVariableOrWriteNode,
+             Prism::LocalVariableAndWriteNode
+          patch_variable_name_only(subnode, patches, rename_map)
+
+        # Instance variables
+        when Prism::InstanceVariableReadNode
+          patch_variable(subnode, patches, rename_map) if @features[:ivars]
+        when Prism::InstanceVariableWriteNode
+          patch_variable_name_only(subnode, patches, rename_map) if @features[:ivars]
+        when Prism::InstanceVariableOperatorWriteNode,
+             Prism::InstanceVariableOrWriteNode,
+             Prism::InstanceVariableAndWriteNode
+          patch_variable_name_only(subnode, patches, rename_map) if @features[:ivars]
+        when Prism::InstanceVariableTargetNode
+          patch_variable(subnode, patches, rename_map) if @features[:ivars]
+
+        # Class variables
+        when Prism::ClassVariableReadNode
+          patch_variable(subnode, patches, rename_map) if @features[:cvars]
+        when Prism::ClassVariableWriteNode
+          patch_variable_name_only(subnode, patches, rename_map) if @features[:cvars]
+        when Prism::ClassVariableOperatorWriteNode,
+             Prism::ClassVariableOrWriteNode,
+             Prism::ClassVariableAndWriteNode
+          patch_variable_name_only(subnode, patches, rename_map) if @features[:cvars]
+        when Prism::ClassVariableTargetNode
+          patch_variable(subnode, patches, rename_map) if @features[:cvars]
+
+        # Global variables
+        when Prism::GlobalVariableReadNode
+          patch_variable(subnode, patches, rename_map) if @features[:gvars]
+        when Prism::GlobalVariableWriteNode
+          patch_variable_name_only(subnode, patches, rename_map) if @features[:gvars]
+        when Prism::GlobalVariableOperatorWriteNode,
+             Prism::GlobalVariableOrWriteNode,
+             Prism::GlobalVariableAndWriteNode
+          patch_variable_name_only(subnode, patches, rename_map) if @features[:gvars]
+        when Prism::GlobalVariableTargetNode
+          patch_variable(subnode, patches, rename_map) if @features[:gvars]
+
+        # Def params
+        when Prism::DefNode
+          patch_def_params(subnode, patches, analysis, :param_names)
+
+        # Block params
+        when Prism::CallNode
+          patch_block_params(subnode, patches, block_param_names_map)
+
+        # For node — patch index and walk body/collection manually to avoid
+        # double-patching the index via LocalVariableTargetNode handler
+        when Prism::ForNode
+          patch_for_node(subnode, patches, analysis, :for_index_mangled)
+          callback = proc { |n| handle_node(n, patches, analysis, rename_map, block_param_names_map) } #: ^(Prism::Node) -> (Symbol | nil)
+          walk_prism(subnode.collection, &callback)
+          walk_prism(subnode.statements, &callback)
+          :skip_children
+
+        # Hash assoc shorthand
+        when Prism::KeywordHashNode
+          callback = proc { |n| handle_node(n, patches, analysis, rename_map, block_param_names_map) } #: ^(Prism::Node) -> (Symbol | nil)
+          patch_keyword_hash(subnode, patches, rename_map, &callback)
+          :skip_children
+        when Prism::AssocNode
+          patch_assoc(subnode, patches, rename_map)
+        end
+      end
+    end
+  end
+end