ryac 0.2.0

data/lib/ryac/analysis/cvar/collection.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Ryac
+  module AnalysisPhases
+    DYNAMIC_CVAR_METHODS = %i[
+      class_variable_get class_variable_set
+      class_variable_defined? class_variables
+      remove_class_variable
+    ].freeze
+
+    CVAR_WRITE_NODES = [
+      Prism::ClassVariableWriteNode,
+      Prism::ClassVariableTargetNode,
+      Prism::ClassVariableOperatorWriteNode,
+      Prism::ClassVariableOrWriteNode,
+      Prism::ClassVariableAndWriteNode
+    ].freeze
+
+    def collect_cvar_definitions(prism_root)
+      Nesting.each(prism_root) do |node, cpath, _singleton|
+        case node
+        when Prism::ClassVariableReadNode, *CVAR_WRITE_NODES
+          # @type var node: Prism::ClassVariableReadNode | cvar_write_node
+          @cvar_rename_mapping.add_site(cpath, node.name, node)
+        end
+      end
+    end
+
+    def scan_dynamic_cvar_access(prism_root)
+      scan_dynamic_sigil_access(prism_root, DYNAMIC_CVAR_METHODS, @cvar_rename_mapping)
+    end
+
+    def merge_inherited_cvars
+      merge_inherited_sites(@cvar_rename_mapping)
+    end
+  end
+end

data/lib/ryac/analysis/gvar/collection.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Ryac
+  module AnalysisPhases
+    GVAR_NODES = [
+      Prism::GlobalVariableReadNode,
+      Prism::GlobalVariableWriteNode,
+      Prism::GlobalVariableTargetNode,
+      Prism::GlobalVariableOperatorWriteNode,
+      Prism::GlobalVariableOrWriteNode,
+      Prism::GlobalVariableAndWriteNode
+    ].freeze
+
+    def collect_gvar_definitions(prism_root)
+      AstUtils.each_node(prism_root) do |node|
+        case node
+        when *GVAR_NODES
+          # @type var node: gvar_node
+          @gvar_rename_mapping.add_site(node.name, node,
+                                        write: !node.is_a?(Prism::GlobalVariableReadNode))
+        end
+      end
+    end
+
+    # `alias $new $old` aliases the *variable*, so the two names refer to one
+    # storage cell; renaming either side independently would sever them.
+    def scan_alias_globals(prism_root)
+      AstUtils.each_node(prism_root) do |node|
+        next unless node.is_a?(Prism::AliasGlobalVariableNode)
+
+        @gvar_rename_mapping.exclude_name(node.new_name.slice.to_sym)
+        @gvar_rename_mapping.exclude_name(node.old_name.slice.to_sym)
+      end
+    end
+  end
+end

data/lib/ryac/analysis/gvar/rename_mapping.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Ryac
+  class GvarRenameMapping
+    # One pairing of English name to punctuation spelling. SpellingShorten
+    # rewrites reads and plain writes to the short form; both spellings also
+    # join BUILT_IN_GLOBALS below, so the node kinds it does not rewrite
+    # (targets, operator/or/and writes) can never be renamed either.
+    PERL_SPELLINGS = {
+      '$PROGRAM_NAME': '$0',
+      '$LOAD_PATH': '$:',
+      '$LOADED_FEATURES': '$"',
+    }.freeze
+
+    # Built-in globals that must never be renamed: Ruby defines their
+    # storage, so a renamed spelling reads nil and writes into a dead cell.
+    BUILT_IN_GLOBALS = (Set.new(%i[
+      $stdout $stderr $stdin $DEBUG $VERBOSE $FILENAME
+      $ERROR_INFO $ERROR_POSITION $FIELD_SEPARATOR $OFS $OUTPUT_FIELD_SEPARATOR
+      $RS $INPUT_RECORD_SEPARATOR $ORS $OUTPUT_RECORD_SEPARATOR
+      $INPUT_LINE_NUMBER $NR $LAST_READ_LINE $DEFAULT_OUTPUT $DEFAULT_INPUT
+      $PID $PROCESS_ID $CHILD_STATUS $LAST_MATCH_INFO $IGNORECASE
+      $ARGV $MATCH $PREMATCH $POSTMATCH $LAST_PAREN_MATCH $FS
+      $0 $: $; $, $. $/ $\\ $_ $< $> $! $@ $~ $& $` $' $+ $*
+      $" $? $$ $-0 $-F $-I $-K $-W $-a $-d $-i $-l $-p $-v $-w
+      $1 $2 $3 $4 $5 $6 $7 $8 $9
+    ]) + PERL_SPELLINGS.keys + PERL_SPELLINGS.values.map(&:to_sym)).freeze
+
+    def initialize
+      @gvars = {}
+      @excluded_names = Set.new
+      @written_names = Set.new
+      @node_short_names = {}
+    end
+
+    def add_site(name, node, write: false)
+      return if BUILT_IN_GLOBALS.include?(name)
+      @written_names << name if write
+      @gvars[name] ||= []
+      @gvars[name] << node
+    end
+
+    def exclude_name(name)
+      @excluded_names << name
+    end
+
+    PREFIX = '$'
+    # Sigil + one character is already minimal — the same rule the
+    # SiteBucketMapping families derive from their prefix.
+    KEPT_NAME_MAX = PREFIX.size + 1
+
+    def assign_short_names
+      existing_names = Set.new
+      @gvars.each_key do |name|
+        existing_names << name.to_s if name.to_s.size <= KEPT_NAME_MAX
+      end
+
+      generator = NameGenerator.new(existing_names, prefix: PREFIX)
+      sorted_gvars = @gvars.sort_by do |name, nodes|
+        -(name.to_s.size * nodes.size)
+      end
+
+      sorted_gvars.each do |name, nodes|
+        next if @excluded_names.include?(name)
+        next if name.to_s.size <= KEPT_NAME_MAX
+        # A global the program only reads is either a built-in this list
+        # does not know or nil everywhere — renaming it can only break.
+        next unless @written_names.include?(name)
+
+        short_name = generator.next_name
+        savings = (name.to_s.size - short_name.size) * nodes.size
+        next unless savings > 0
+
+        nodes.each { |n| @node_short_names[AstUtils.location_key(n)] = short_name }
+      end
+    end
+
+    def node_mapping
+      @node_short_names.dup
+    end
+  end
+end

data/lib/ryac/analysis/ivar/collection.rb

@@ -0,0 +1,281 @@
+# frozen_string_literal: true
+
+module Ryac
+  module AnalysisPhases
+    DYNAMIC_IVAR_METHODS = %i[
+      instance_variable_get instance_variable_set
+      instance_variable_defined? remove_instance_variable
+      instance_variables
+    ].freeze
+
+    ATTR_DECLARATION_METHODS = %i[attr attr_reader attr_writer attr_accessor].freeze
+
+    IVAR_WRITE_NODES = [
+      Prism::InstanceVariableWriteNode,
+      Prism::InstanceVariableTargetNode,
+      Prism::InstanceVariableOperatorWriteNode,
+      Prism::InstanceVariableOrWriteNode,
+      Prism::InstanceVariableAndWriteNode
+    ].freeze
+
+    def collect_ivar_definitions(prism_root, attr_backed)
+      Nesting.each(prism_root) do |node, cpath, _singleton, _in_def|
+        case node
+        when Prism::InstanceVariableReadNode, *IVAR_WRITE_NODES
+          # @type var node: Prism::InstanceVariableReadNode | ivar_write_node
+          next if attr_backed[cpath]&.include?(node.name)
+          @ivar_rename_mapping.add_site(cpath, node.name, node)
+        end
+      end
+    end
+
+    def collect_attr_backed_ivars(prism_root)
+      result = Hash.new { |h, k| h[k] = Set.new } #: Hash[Array[Symbol], Set[Symbol]]
+      each_attr_declaration(prism_root, ATTR_DECLARATION_METHODS, require_class_body: false) do |_node, cpath, _singleton, sym|
+        result[cpath] << :"@#{sym}"
+      end
+      result
+    end
+
+    def scan_dynamic_ivar_access(prism_root)
+      scan_dynamic_sigil_access(prism_root, DYNAMIC_IVAR_METHODS, @ivar_rename_mapping)
+    end
+
+    def merge_inherited_ivars
+      merge_inherited_sites(@ivar_rename_mapping)
+    end
+
+    def reserve_attr_ivar_names(prism_root)
+      each_attr_declaration(prism_root, %i[attr_reader attr_accessor]) do |_node, cpath, singleton, sym|
+        getter_short = @method_rename_mapping.short_name_for_key([cpath, singleton, sym].freeze)
+        next unless getter_short
+        @ivar_rename_mapping.reserve_name(cpath, "@#{getter_short}")
+      end
+    end
+
+    # attr declarations rename along two paths. Path A (method-driven): the
+    # getter already got a short name from method renaming, and the backing
+    # ivar follows it. Path B (ivar-driven): the getter wasn't renamed, so a
+    # name is chosen from the ivar side and the getter (and setter) follow.
+    # Phase 1 decides every name, phase 2 applies them — declaration, ivar
+    # sites, and accessor call sites — only once all decisions are in.
+    def coordinate_attr_renames(prism_root, rename_map, attr_ivar_entries)
+      path_a_info, path_b_info = classify_attr_declarations(prism_root)
+      return {} unless path_a_info.any? || path_b_info.any?
+
+      path_a_mapping = path_a_info.to_h { |info| [info[:ivar_key], "@#{info[:getter_short]}"] }
+      ivar_nodes_by_key = collect_ivar_nodes_by_key(prism_root)
+      path_b_mapping, path_b_method_mapping =
+        assign_ivar_driven_names(path_b_info, ivar_nodes_by_key, path_a_mapping, rename_map)
+
+      apply_ivar_renames(ivar_nodes_by_key, path_a_mapping.merge(path_b_mapping), attr_ivar_entries)
+      apply_accessor_call_renames(path_a_info, path_b_info, path_b_method_mapping, rename_map)
+      build_attr_rename_map(path_a_info, path_b_info, path_b_method_mapping)
+    end
+
+    private
+
+    # A receiverless (or explicit-self) call to a dynamic sigil-variable API
+    # can reach any name in its class — nothing in that cpath is safe to
+    # rename. Shared by the ivar and cvar scans, which differ only in table
+    # and mapping.
+    def scan_dynamic_sigil_access(prism_root, methods, mapping)
+      Nesting.each(prism_root) do |node, cpath, _singleton, _in_def|
+        next unless node.is_a?(Prism::CallNode)
+        next unless methods.include?(node.name)
+
+        recv = node.receiver
+        mapping.exclude_cpath(cpath) if recv.nil? || recv.is_a?(Prism::SelfNode)
+      end
+    end
+
+    def merge_inherited_sites(mapping)
+      cpaths = [] #: Array[Array[Symbol]]
+      mapping.each_canonical_cpath { |c| cpaths << c }
+      cpaths.each do |cpath|
+        @oracle.each_ancestor_cpath(cpath, false) do |ancestor_cpath|
+          next if ancestor_cpath == cpath
+          mapping.merge_with_ancestor(cpath, ancestor_cpath)
+        end
+      end
+    end
+
+    def classify_attr_declarations(prism_root)
+      path_a_info = [] #: Array[attr_info]
+      path_b_info = [] #: Array[attr_info]
+      each_attr_declaration(prism_root, %i[attr_reader attr_accessor]) do |node, cpath, singleton, sym|
+        method_key = [cpath, singleton, sym].freeze
+        getter_short = @method_rename_mapping.short_name_for_key(method_key)
+        info = {
+          cpath: cpath, singleton: singleton, mid: sym,
+          accessor: node.name == :attr_accessor,
+          loc_key: AstUtils.location_key(node),
+          ivar_key: [cpath, :"@#{sym}"],
+          method_key: method_key
+        }
+        if getter_short
+          info[:getter_short] = getter_short
+          path_a_info << info
+        elsif @method_rename_mapping.has_method?(method_key) &&
+              @method_rename_mapping.group_keys(method_key) == [method_key]
+          # An excluded mid (dynamic dispatch, unresolved call, hidden attr
+          # write, ...) was left alone for a reason — the ivar side must not
+          # rename it either. A group spanning other keys means the mid's
+          # sites are shared with defs this declaration does not cover.
+          path_b_info << info
+        end
+      end
+      [path_a_info, path_b_info]
+    end
+
+    def collect_ivar_nodes_by_key(prism_root)
+      ivar_nodes_by_key = Hash.new { |h, k| h[k] = [] } #: Hash[[Array[Symbol], Symbol], Array[Prism::Node]]
+      Nesting.each(prism_root) do |node, cpath, _singleton, _in_def|
+        case node
+        when Prism::InstanceVariableReadNode, *IVAR_WRITE_NODES
+          # @type var node: Prism::InstanceVariableReadNode | ivar_write_node
+          ivar_nodes_by_key[[cpath, node.name]] << node
+        end
+      end
+      ivar_nodes_by_key
+    end
+
+    # Path B: pick a fresh @name whose bare form is free as a method name too,
+    # then keep it only when renaming ivar sites plus accessor calls saves
+    # more than it costs.
+    def assign_ivar_driven_names(path_b_info, ivar_nodes_by_key, path_a_mapping, rename_map)
+      path_b_mapping = {} #: Hash[[Array[Symbol], Symbol], String]
+      path_b_method_mapping = {} #: Hash[[Array[Symbol], Symbol], Symbol]
+      return [path_b_mapping, path_b_method_mapping] if path_b_info.none?
+
+      used_ivar_names = @ivar_rename_mapping.node_mapping.values.to_set
+      used_ivar_names.merge(path_a_mapping.values)
+      used_method_names = rename_map.values.to_set
+      scope_vars = MethodRenameMapping.build_scope_vars(@scope_mappings)
+      generator = NameGenerator.new(prefix: "@")
+
+      path_b_info
+        .sort_by do |info|
+          ivar_name = info[:ivar_key][1]
+          count = ivar_nodes_by_key[info[:ivar_key]].size
+          -(ivar_name.to_s.size * count)
+        end
+        .each do |info|
+          ivar_key = info[:ivar_key]
+          ivar_name = ivar_key[1]
+          ivar_count = ivar_nodes_by_key[ivar_key].size
+          next if ivar_count == 0
+          next if ivar_name.to_s.size <= '@'.size + 1 # sigil + one character is already minimal
+
+          getter_calls = 0
+          implicit_scope_ids = [] #: Array[scope_id]
+          @method_rename_mapping.each_group_call_site(info[:method_key]) do |_site, scope_id|
+            getter_calls += 1
+            implicit_scope_ids << scope_id if scope_id
+          end
+
+          short_name, method_short = loop do #: [String, Symbol]
+            candidate = generator.next_name
+            method_candidate = candidate.delete_prefix("@").to_sym
+
+            next if used_ivar_names.include?(candidate)
+            next if used_method_names.include?(method_candidate.to_s)
+            next if @oracle.method_defined?(info[:cpath], info[:singleton], method_candidate)
+            # A bare renamed getter call would parse as the local if a visible
+            # local already owns the candidate at an implicit-receiver site.
+            next if implicit_scope_ids.any? { |sid| scope_vars[sid].include?(method_candidate.to_s) }
+
+            break [candidate, method_candidate]
+          end
+
+          setter_calls = 0
+          if info[:accessor]
+            setter_calls = @oracle.method_call_count(info[:cpath], info[:singleton], :"#{info[:mid]}=")
+          end
+
+          ivar_savings = (ivar_name.to_s.size - short_name.size) * ivar_count
+          method_savings = (info[:mid].to_s.size - method_short.to_s.size) * (getter_calls + setter_calls + 1)
+          next unless ivar_savings + method_savings > 0
+
+          used_ivar_names << short_name
+          used_method_names << method_short.to_s
+
+          path_b_mapping[ivar_key] = short_name
+          path_b_method_mapping[ivar_key] = method_short
+        end
+
+      [path_b_mapping, path_b_method_mapping]
+    end
+
+
+    # Ivar read/write sites take their attr's name; a subclass's sites follow
+    # the ancestor that declared the attr.
+    def apply_ivar_renames(ivar_nodes_by_key, combined_mapping, attr_ivar_entries)
+      ivar_nodes_by_key.each do |(cpath, ivar_name), nodes_list|
+        short = combined_mapping[[cpath, ivar_name]]
+        unless short
+          @oracle.each_ancestor_cpath(cpath, false) do |ancestor_cpath|
+            next if ancestor_cpath == cpath
+            short = combined_mapping[[ancestor_cpath, ivar_name]]
+            break if short
+          end
+        end
+        next unless short
+        nodes_list.each { |n| attr_ivar_entries[AstUtils.location_key(n)] = short }
+      end
+    end
+
+    def apply_accessor_call_renames(path_a_info, path_b_info, path_b_method_mapping, rename_map)
+      path_a_info.each do |info|
+        next unless info[:accessor]
+        @oracle.each_call_site_key(info[:cpath], info[:singleton], :"#{info[:mid]}=") do |key|
+          rename_map[key] = "#{info[:getter_short]}="
+        end
+      end
+
+      path_b_info.each do |info|
+        method_short = path_b_method_mapping[info[:ivar_key]]
+        next unless method_short
+
+        # The mapping's group sites, not the oracle's: sites attached by the
+        # unresolved-call pass exist only in the mapping, and missing one here
+        # would leave it calling the old name.
+        @method_rename_mapping.each_group_call_site(info[:method_key]) do |site, _scope_id|
+          rename_map[AstUtils.location_key(site)] = method_short.to_s
+        end
+
+        next unless info[:accessor]
+        @oracle.each_call_site_key(info[:cpath], info[:singleton], :"#{info[:mid]}=") do |key|
+          rename_map[key] = "#{method_short}="
+        end
+      end
+    end
+
+    def build_attr_rename_map(path_a_info, path_b_info, path_b_method_mapping)
+      # Values are the getter shorts: path A stores Strings, path B Symbols;
+      # consumers interpolate, so both work.
+      attr_rename_map = {} #: Hash[location_key, Hash[Symbol, untyped]]
+      path_a_info.each do |info|
+        (attr_rename_map[info[:loc_key]] ||= {})[info[:mid]] = info[:getter_short]
+      end
+      path_b_info.each do |info|
+        method_short = path_b_method_mapping[info[:ivar_key]]
+        next unless method_short
+        (attr_rename_map[info[:loc_key]] ||= {})[info[:mid]] = method_short
+      end
+      attr_rename_map
+    end
+
+    # attr declarations with meta semantics, one yield per symbol argument.
+    # With require_class_body: false, bare attr_* calls anywhere count — the
+    # attr-backed scan wants those too, since the methods they define still
+    # read the ivar.
+    def each_attr_declaration(prism_root, methods, require_class_body: true)
+      Nesting.each_meta_call(prism_root, methods, loose: !require_class_body) do |node, cpath, singleton|
+        AstUtils.symbol_arguments(node).each do |sym|
+          yield node, cpath, singleton, sym
+        end
+      end
+    end
+  end
+end

data/lib/ryac/analysis/keyword/collection.rb

@@ -0,0 +1,213 @@
+# frozen_string_literal: true
+
+module Ryac
+  module AnalysisPhases
+    def collect_keyword_info(prism_root)
+      @keyword_def_node_registry = {}
+      @keyword_forwarding_super_keys = Set.new
+
+      Nesting.each_method_definition(prism_root) do |node, method_key|
+        keywords = def_keyword_names(node)
+        next if keywords.empty?
+
+        keywords.each { |sym| @keyword_rename_mapping.add_keyword_def(method_key, sym) }
+
+        @keyword_def_node_registry[method_key] ||= []
+        @keyword_def_node_registry[method_key] << node
+
+        @keyword_rename_mapping.exclude_method(method_key) if def_keyword_rest?(node)
+
+        @keyword_forwarding_super_keys << method_key if forwards_parameters_to_super?(node)
+      end
+
+      collect_keyword_call_sites(prism_root)
+    end
+
+    private
+
+    def def_keyword_names(def_node)
+      params = def_node.parameters
+      return [] unless params
+
+      names = [] #: Array[Symbol]
+      params.keywords&.each do |kw|
+        names << kw.name if kw.respond_to?(:name)
+      end
+      names
+    end
+
+    def def_keyword_rest?(def_node)
+      def_node.parameters&.keyword_rest.is_a?(Prism::KeywordRestParameterNode)
+    end
+
+    # A bare `super` forwards this method's parameters to the parent by name, so
+    # the keyword names have to keep matching the parent's signature. When the
+    # parent is a def we also collected, collect_keyword_call_sites merges the
+    # two groups and both sides are renamed together; this only reports the
+    # forwarding, the decision is made once we know whether that merge happened.
+    def forwards_parameters_to_super?(def_node)
+      found = false
+      walk = lambda do |n|
+        next if found || !n.is_a?(Prism::Node)
+        # A nested def has its own parameters; its `super` is not about ours.
+        next if n.is_a?(Prism::DefNode)
+        if n.is_a?(Prism::ForwardingSuperNode)
+          found = true
+          next
+        end
+        n.compact_child_nodes.each { |child| walk.call(child) }
+      end
+      walk.call(def_node.body)
+      found
+    end
+
+    # Everything call sites decide about keyword renames, in order: literal
+    # keywords register with their method, super-forwarding merges child and
+    # parent groups (or excludes the child when the parent is outside our
+    # control), polymorphic call sites merge every method they can reach,
+    # methods no resolved call reaches are excluded, and unresolved
+    # keyword-writing calls disqualify their method name entirely.
+    def collect_keyword_call_sites(prism_root)
+      sites = register_keyword_calls
+      merge_super_forwarding(sites[:super_merges])
+      merge_polymorphic_keyword_groups(sites[:call_node_to_keys])
+      exclude_unreachable_keyword_methods(sites[:zero_call_keys], sites[:super_merges])
+      exclude_unresolved_keyword_calls(prism_root, sites[:resolved_site_keys])
+      exclude_method_valued_shorthand_calls(prism_root)
+    end
+
+    def register_keyword_calls
+      call_node_to_keys = Hash.new { |h, k| h[k] = [] } #: Hash[location_key, Array[method_key]]
+      super_merges = [] #: Array[[method_key, method_key]]
+      zero_call_keys = [] #: Array[method_key]
+      resolved_site_keys = Set.new
+
+      @keyword_rename_mapping.each_method_key do |key|
+        call_count = 0
+        splat_seen = false
+
+        @oracle.each_caller(key[0], key[1], key[2]) do |info|
+          resolved_site_keys << AstUtils.location_key(info.prism_node) if info.prism_node
+          next if splat_seen
+
+          if info.super
+            # caller_cpath is always present on super records
+            entry = [info.caller_cpath, key[1], key[2]].freeze #: method_key
+            super_merges << [entry, key]
+            next
+          end
+
+          if info.prism_node.nil?
+            # An unrewritable dispatch with no source site: the method is
+            # reached in a way we cannot see, which is exactly what the
+            # zero-call rule below covers — it must not count as a seen call.
+            next
+          end
+
+          call_count += 1
+
+          next unless info.keyword_entries
+
+          if info.keyword_splat
+            @keyword_rename_mapping.exclude_method(key)
+            splat_seen = true
+            next
+          end
+
+          info.keyword_entries.each do |sym_node, val_node|
+            @keyword_rename_mapping.add_keyword_call(key, sym_node.unescaped.to_sym, sym_node, val_node)
+          end
+
+          call_node_to_keys[AstUtils.location_key(info.prism_node)] << key
+        end
+
+        zero_call_keys << key if call_count == 0 && @oracle.method_known?(key[0], key[1], key[2])
+      end
+
+      { call_node_to_keys: call_node_to_keys, super_merges: super_merges,
+        zero_call_keys: zero_call_keys, resolved_site_keys: resolved_site_keys }
+    end
+
+    # Supers are discovered from the parent's call boxes, so a `super` whose
+    # parent we never collected produces no merge at all. That parent's
+    # signature is outside our control — Data.define and Struct.new generate
+    # theirs from the member list — and renaming only the child raises
+    # "unknown keywords" at runtime, so leave those keywords alone.
+    def merge_super_forwarding(super_merges)
+      super_merges.each do |child_key, parent_key|
+        @keyword_rename_mapping.merge_groups(child_key, parent_key)
+      end
+
+      merged_children = Set.new(super_merges.map { |child_key, _| child_key })
+      @keyword_forwarding_super_keys.each do |key|
+        next if merged_children.include?(key)
+        @keyword_rename_mapping.exclude_method(key)
+      end
+    end
+
+    def merge_polymorphic_keyword_groups(call_node_to_keys)
+      call_node_to_keys.each_value do |keys|
+        next if keys.size < 2
+        (1...keys.size).each { |i| @keyword_rename_mapping.merge_groups(keys[i - 1], keys[i]) }
+      end
+    end
+
+    # A keyword-taking method type analysis knows but connects no call to is
+    # reachable in ways we cannot see; renaming its keywords would strand the
+    # unseen callers. A method reached through super stays: the merge already
+    # ties it to callers we did see.
+    def exclude_unreachable_keyword_methods(zero_call_keys, super_merges)
+      super_targets = super_merges.map(&:last).to_set
+      zero_call_keys.each do |key|
+        next if super_targets.include?(key)
+        @keyword_rename_mapping.exclude_method(key)
+      end
+    end
+
+    # A call to a keyword-taking method that type inference never connected to
+    # its target would keep its written keywords while the def's got renamed —
+    # so any such call disqualifies the whole method name. Only calls that
+    # actually write keywords (literals or a **splat) can go stale, though: a
+    # keyword-less call is untouched by the rename no matter which method it
+    # reaches, and unrelated methods sharing the name would otherwise poison
+    # each other through it.
+    def exclude_unresolved_keyword_calls(prism_root, resolved_site_keys)
+      keyword_mids = Set.new
+      @keyword_rename_mapping.each_method_key { |key| keyword_mids << key[2] }
+      return if keyword_mids.empty?
+
+      unresolved_mids = Set.new
+      AstUtils.each_node(prism_root) do |node|
+        next unless node.is_a?(Prism::CallNode)
+        if keyword_mids.include?(node.name) &&
+           carries_keyword_arguments?(node) &&
+           !resolved_site_keys.include?(AstUtils.location_key(node))
+          unresolved_mids << node.name
+        end
+      end
+
+      @keyword_rename_mapping.exclude_methods_by_mid(unresolved_mids)
+    end
+
+    # A keyword shorthand can pun on a METHOD, not a local: `n(label:)` calls
+    # `label` for its value. Renaming the keyword rewrites the pun and with it
+    # the method the value resolves to — methods called with such a pun keep
+    # their keywords.
+    def exclude_method_valued_shorthand_calls(prism_root)
+      punned_mids = Set.new
+      AstUtils.each_node(prism_root) do |node|
+        next unless node.is_a?(Prism::CallNode)
+        node.arguments&.arguments&.each do |arg|
+          punned_mids << node.name if AstUtils.shorthand_pun_values(arg).any?
+        end
+      end
+      @keyword_rename_mapping.exclude_methods_by_mid(punned_mids) if punned_mids.any?
+    end
+
+    def carries_keyword_arguments?(call_node)
+      call_node.arguments&.arguments&.any? { |arg| arg.is_a?(Prism::KeywordHashNode) } || false
+    end
+
+    public
+  end
+end