ryac 0.2.0

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

@@ -0,0 +1,332 @@
+# frozen_string_literal: true
+
+module Ryac
+  module AnalysisPhases
+    # One classified walk of every constant fact in the tree, shared by
+    # definition collection, usage counting, external-reference collection and
+    # the analyzer's resolution precompute — so the node-shape case analysis
+    # lives in exactly one place. Yields (kind, node, cpath, singleton, in_def):
+    #
+    #   :class_def  class/module definition; cpath is the path it creates
+    #   :read       a constant read at the node's own position (cpath nil)
+    #   :write      an assignment defining cpath
+    #
+    # A compound write (`X ||= 1`) and a qualified target in multiple
+    # assignment (`Foo::A, b = ary`) read as well as write, so they yield
+    # both a :read and a :write. Writes with no static path yield nothing.
+    def each_constant_event(prism_root)
+      Nesting.each(prism_root) do |node, nesting, singleton, in_def|
+        case node
+        when Prism::ClassNode, Prism::ModuleNode
+          cpath = class_definition_cpath(node, nesting)
+          yield :class_def, node, cpath, singleton, in_def if cpath
+        when Prism::ConstantReadNode, Prism::ConstantPathNode
+          yield :read, node, nil, singleton, in_def
+        when Prism::ConstantWriteNode
+          yield :write, node, nesting + [node.name], singleton, in_def
+        when Prism::ConstantTargetNode
+          yield :write, node, nesting + [node.name], singleton, in_def
+        when Prism::ConstantOperatorWriteNode, Prism::ConstantOrWriteNode, Prism::ConstantAndWriteNode
+          yield :read, node, nil, singleton, in_def
+          yield :write, node, nesting + [node.name], singleton, in_def
+        when Prism::ConstantPathTargetNode
+          yield :read, node, nil, singleton, in_def
+          cpath = qualified_write_cpath(node, nesting)
+          yield :write, node, cpath, singleton, in_def if cpath
+        when Prism::ConstantPathWriteNode
+          cpath = qualified_write_cpath(node.target, nesting, strip_doubled_nesting: true)
+          yield :write, node, cpath, singleton, in_def if cpath
+        when Prism::ConstantPathOperatorWriteNode, Prism::ConstantPathOrWriteNode, Prism::ConstantPathAndWriteNode
+          cpath = qualified_write_cpath(node.target, nesting)
+          yield :write, node, cpath, singleton, in_def if cpath
+        end
+      end
+    end
+
+    # The fully-qualified path a class/module definition creates, or nil when
+    # the written path is not static.
+    def class_definition_cpath(node, nesting)
+      qualified_write_cpath(node.constant_path, nesting)
+    end
+
+    # The path a qualified assignment target names, or nil when it is not
+    # static (`self::X`, `expr::X`). A plain path write that repeats the
+    # lexical nesting (`Foo::Bar::X = 1` inside module Foo; module Bar) names
+    # the same constant the bare write would, so the doubled prefix is dropped
+    # — but only for that form: compound and multiple-target writes
+    # concatenate as written, mirroring the previous implementation.
+    def qualified_write_cpath(target, nesting, strip_doubled_nesting: false)
+      segments, absolute = Nesting.path_segments(target)
+      return nil unless segments
+      return segments if absolute
+      return segments if strip_doubled_nesting && segments.take(nesting.size) == nesting
+
+      nesting + segments
+    end
+
+    # The constant path as written, without any resolution — partial when the
+    # chain hangs off a dynamic root (`expr::CONST` gives just [:CONST]).
+    def syntactic_const_segments(node)
+      case node
+      when Prism::ConstantPathNode, Prism::ConstantPathTargetNode
+        segments = [node.name]
+        current = node.parent
+        while current.is_a?(Prism::ConstantPathNode)
+          segments.unshift(current.name)
+          current = current.parent
+        end
+        segments.unshift(current.name) if current.is_a?(Prism::ConstantReadNode)
+        segments
+      else
+        # Reached only for bare named nodes (ConstantRead and the compound
+        # constant writes), which all carry #name; the parameter stays
+        # Prism::Node for the shared walk.
+        [node.name] # steep:ignore NoMethod
+      end
+    end
+
+    # `X = Struct.new(...)` / `X = Data.define(...)` assigns a class, so the
+    # constant registers as a class definition: it renames exactly when class
+    # renaming is on, and reopenings resolve through the same machinery.
+    def struct_definition_write?(node)
+      return false unless node.is_a?(Prism::ConstantWriteNode) || node.is_a?(Prism::ConstantPathWriteNode)
+
+      value = node.value
+      return false unless value.is_a?(Prism::CallNode)
+
+      receiver = value.receiver
+      return false unless receiver.is_a?(Prism::ConstantReadNode)
+
+      (value.name == :new && receiver.name == :Struct) ||
+        (value.name == :define && receiver.name == :Data)
+    end
+
+    def collect_constants(prism_root)
+      each_constant_event(prism_root) do |kind, node, cpath, singleton, in_def|
+        case kind
+        when :class_def
+          type = node.is_a?(Prism::ClassNode) ? :class : :module
+          @constant_mapping.add_definition_with_path(cpath, definition_type: type)
+        when :write
+          # Skip constants defined inside `class << self` — they live on the
+          # metaclass and cannot be accessed as Foo::X, so alias declarations
+          # would fail at runtime. (An assignment inside a def body there is a
+          # plain assignment and still registers.)
+          next if singleton && !in_def
+
+          type = struct_definition_write?(node) ? :class : :value
+          @constant_mapping.add_definition_with_path(cpath, definition_type: type)
+        end
+      end
+    end
+
+    def exclude_private_constants(prism_root)
+      Nesting.each(prism_root) do |node, nesting, _singleton, _in_def|
+        next unless node.is_a?(Prism::CallNode)
+        next unless %i[private_constant public_constant].include?(node.name)
+
+        AstUtils.symbol_arguments(node).each do |sym|
+          @constant_mapping.exclude_path(nesting + [sym])
+        end
+      end
+    end
+
+    def count_constant_references(prism_root)
+      each_constant_event(prism_root) do |kind, node, cpath, _singleton, _in_def|
+        case kind
+        when :class_def, :write
+          @constant_mapping.increment_usage_by_path(cpath)
+        when :read
+          increment_constant_read_usage(node)
+        end
+      end
+    end
+
+    def increment_constant_read_usage(node)
+      user_path = resolve_user_defined_cpath(node)
+      if user_path
+        @constant_mapping.increment_usage_by_path(user_path)
+      else
+        @constant_mapping.increment_usage(node.name) # steep:ignore NoMethod
+      end
+    end
+
+    def resolve_user_defined_cpath(node)
+      [@oracle.resolve_constant_read(node), syntactic_const_segments(node)].each do |cpath|
+        return cpath if cpath && @constant_mapping.user_defined_path?(cpath)
+      end
+      nil
+    end
+
+    # Where a superclass reference lands, for the alias patcher. A qualified
+    # path is taken as written; a bare name is meaningful only when it names a
+    # user-defined constant in the class's enclosing scope.
+    def resolve_superclass_path(superclass_node, class_cpath)
+      case superclass_node
+      when Prism::ConstantPathNode
+        syntactic_const_segments(superclass_node)
+      when Prism::ConstantReadNode
+        full_path = class_cpath[0...-1] + [superclass_node.name] # steep:ignore NoMethod
+        full_path if @constant_mapping&.user_defined_path?(full_path)
+      end
+    end
+
+    # A closed-world walk sees each textual reference once, but type analysis
+    # can record more read sites than the text shows (reads reached through
+    # resolution rather than spelling). Take whichever count is higher, so a
+    # rename is never judged unprofitable on an undercount.
+    def augment_constant_counts_via_oracle
+      @constant_mapping.each_user_defined_path do |cpath|
+        oracle_count = @oracle.constant_read_count(cpath)
+        current_count = @constant_mapping.usage_count_for_path(cpath)
+        @constant_mapping.set_usage_count_by_path(cpath, oracle_count) if oracle_count > current_count
+      end
+    end
+
+    # Location-keyed maps the patchers consume: resolution and full path per
+    # read, write cpath per assignment, cpath and superclass per definition.
+    def precompute_constant_resolution
+      @const_resolution_map = {} #: Hash[location_key, Array[Symbol]?]
+      @const_full_path_map = {} #: Hash[location_key, Array[Symbol]]
+      @const_write_cpath_map = {} #: Hash[location_key, Array[Symbol]]
+      @class_cpath_map = {} #: Hash[location_key, Array[Symbol]]
+      @superclass_resolution_map = {} #: Hash[location_key, Array[Symbol]]
+
+      each_constant_event(@prism_root) do |kind, node, cpath, _singleton, _in_def|
+        case kind
+        when :read
+          record_constant_read(node)
+        when :write
+          @const_write_cpath_map[AstUtils.location_key(node)] = cpath
+        when :class_def
+          key = AstUtils.location_key(node)
+          @class_cpath_map[key] = cpath
+          if node.is_a?(Prism::ClassNode) && node.superclass
+            # cpath is never nil for a :class_def event.
+            resolved = resolve_superclass_path(node.superclass, cpath) # steep:ignore ArgumentTypeMismatch
+            @superclass_resolution_map[key] = resolved if resolved
+          end
+        end
+      end
+    end
+
+    def record_constant_read(node)
+      key = AstUtils.location_key(node)
+      resolved = @oracle.resolve_constant_read(node)
+      @const_resolution_map[key] = resolved
+      @const_full_path_map[key] = resolved || syntactic_const_segments(node)
+    end
+
+    def collect_external_references(prism_root)
+      counted_prefix_ids = Set.new
+      prefix_counts = Hash.new(0)
+
+      each_constant_event(prism_root) do |kind, node, _cpath, _singleton, _in_def|
+        next unless kind == :read
+        next if counted_prefix_ids.include?(node.object_id)
+
+        mark_chain_prefixes(node, counted_prefix_ids)
+        prefix = external_prefix_for(node)
+        prefix_counts[prefix] += 1 if prefix
+      end
+
+      prefix_counts.each do |prefix, count|
+        @constant_mapping.add_external_prefix(prefix, usage_count: count)
+      end
+    end
+
+    # Mark the reference's prefix chain so sub-paths are not counted again as
+    # references of their own.
+    def mark_chain_prefixes(node, counted_prefix_ids)
+      current = case node
+                when Prism::ConstantPathNode, Prism::ConstantPathTargetNode then node.parent
+                end
+      while current.is_a?(Prism::ConstantPathNode) || current.is_a?(Prism::ConstantReadNode)
+        counted_prefix_ids << current.object_id
+        current = current.is_a?(Prism::ConstantPathNode) ? current.parent : nil
+      end
+    end
+
+    # The external prefix this reference should be counted under, or nil when
+    # it has none: the reference must not touch the project's own namespace,
+    # and must either resolve through type analysis or — the fallback for gems
+    # with no RBS — be spelled in full from a root that one of the program's
+    # own top-level requires provides. The requires are re-emitted ahead of
+    # the preamble, so such a root provably exists when the alias declaration
+    # runs; without that anchor an alias would turn "NameError if this line is
+    # ever reached" into "NameError at boot", or capture the wrong constant
+    # for a reference that resolves through its nesting at runtime.
+    def external_prefix_for(node)
+      full_path = syntactic_const_segments(node)
+      resolved_cpath = @oracle.resolve_constant_read(node)
+      return nil if @constant_mapping.user_defined_path?(full_path)
+      return nil if resolved_cpath && @constant_mapping.user_defined_path?(resolved_cpath)
+
+      effective_path = resolved_cpath ||
+                       (full_path if complete_const_chain?(node) && required_external_root?(full_path.first))
+      return nil unless effective_path
+      return nil if effective_path.size < 2
+      return nil if @constant_mapping.has_user_defined_prefix?(full_path)
+
+      prefix = effective_path[0...-1]
+      return nil if @constant_mapping.user_defined_path?(prefix)
+
+      prefix
+    end
+
+    # True when the qualified chain is rooted at a plain constant (or written
+    # absolute), so its syntactic segments are its complete spelling.
+    def complete_const_chain?(node)
+      case node
+      when Prism::ConstantPathNode, Prism::ConstantPathTargetNode
+        !Nesting.path_segments(node).nil?
+      else
+        false
+      end
+    end
+
+    def required_external_root?(root)
+      @boot_constant_roots&.include?(root) || false
+    end
+
+  end
+
+  # The top-level constants that exist when the minified program boots,
+  # before any of its own code runs: Ruby's core names plus whatever its
+  # top-level requires provide. Asking a fresh interpreter is what makes
+  # this exact — no naming-convention guessing, and no contamination from
+  # the constants the minifier process itself happens to have loaded.
+  # nil when the probe fails, so callers can fall back conservatively.
+  #
+  # Its own module rather than a phase method: the memo is process state
+  # (one probe per require set, because the probe boots an interpreter),
+  # and process state does not belong on a mixin of per-run phases.
+  module BootConstants
+    @cache = {} #: Hash[Array[String], Set[Symbol]?]
+
+    class << self
+      def for(stdlib_requires)
+        key = stdlib_requires.sort
+        return @cache[key] if @cache.key?(key)
+
+        @cache[key] = probe(stdlib_requires)
+      end
+
+      private
+
+      # The probe must run outside the minifier's bundler context: with it, the
+      # subprocess boots bundler, bundler evaluates the analyzed project's
+      # gemspec-style Gemfile, and the program's own constants leak into the
+      # "exists at boot" answer — under self-hosting, Ryac itself.
+      def probe(stdlib_requires)
+        requires = stdlib_requires.map { |r| "begin;require #{r.dump};rescue LoadError;end" }.join(';')
+        script = "#{requires};puts Object.constants"
+        popen = -> { IO.popen([{ 'RUBYOPT' => nil }, RbConfig.ruby, '-e', script], &:read) } #: ^() -> String
+        out = defined?(Bundler) ? Bundler.with_unbundled_env(&popen) : popen.call
+        Process.last_status&.success? ? out.split.map(&:to_sym).to_set : nil
+      rescue StandardError
+        nil
+      end
+    end
+  end
+end

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

@@ -0,0 +1,346 @@
+# frozen_string_literal: true
+
+require 'set'
+
+module Ryac
+  # Represents an external library constant prefix that can be aliased
+  ExternalPrefixInfo = Struct.new(
+    :prefix_path,    # Array<Symbol> - Prefix path (e.g., [:TypeProf, :Core, :AST])
+    :prefix_string,  # String - Full prefix string (e.g., "TypeProf::Core::AST")
+    :short_name,     # String - Assigned short name (e.g., "Z")
+    :usage_count,    # Integer - Number of references using this prefix
+    :char_savings,   # Integer - Net character savings from aliasing
+    keyword_init: true
+  ) do
+    def initialize(prefix_path: nil, prefix_string: nil, short_name: nil, # steep:ignore UndeclaredMethodDefinition
+                   usage_count: nil, char_savings: nil)
+      # @type self: ExternalPrefixInfo
+      self.prefix_path = prefix_path || []
+      self.prefix_string = prefix_string
+      self.short_name = short_name
+      self.usage_count = usage_count || 0
+      self.char_savings = char_savings || 0
+    end
+  end
+
+  # Represents a user-defined constant found in the source file
+  ConstantInfo = Struct.new(
+    :original_name,   # Symbol - Original constant name (e.g., :MyClass)
+    :full_path,       # Array<Symbol> - Full namespace path (e.g., [:Foo, :Bar, :MyClass])
+    :short_name,      # String - Assigned short name (e.g., "A")
+    :usage_count,     # Integer - Number of references in the file
+    :definition_type, # Symbol - :class, :module, or :value
+    :scope_path,      # Array<Symbol> - Module/class scope where defined
+    keyword_init: true
+  ) do
+    def initialize(original_name: nil, full_path: nil, short_name: nil, # steep:ignore UndeclaredMethodDefinition
+                   usage_count: nil, definition_type: nil, scope_path: nil)
+      # @type self: ConstantInfo
+      self.original_name = original_name
+      self.full_path = full_path || []
+      self.short_name = short_name
+      self.usage_count = usage_count || 0
+      self.definition_type = definition_type
+      self.scope_path = scope_path || []
+    end
+  end
+
+  # Tracks the mapping between original and short constant names
+  # Uses static_cpath (full qualified path) as key to distinguish
+  # constants with same name in different modules.
+  # Also tracks external prefix aliases (absorbed from ExternalPrefixAliaser).
+  class ConstantRenameMapping
+    attr_reader :mappings, :used_short_names
+
+    # boot_roots: the top-level constants that exist when the minified
+    # program boots (core + its own requires), used to spot reopenings of
+    # classes the program didn't create. nil falls back to probing the
+    # minifier's own process, which over-approximates: everything the
+    # minifier has loaded — including, under self-hosting, the analyzed
+    # program itself — then looks like a reopening.
+    def initialize(boot_roots: nil)
+      @boot_roots = boot_roots
+      @mappings = {}           # Hash<Array<Symbol>, ConstantInfo> - key is static_cpath
+      # keyed by the last path segment
+      @by_name = {}
+      @used_short_names = Set.new
+      @external_prefixes = {}
+      @prefix_counts = Hash.new(0) # Hash<Array<Symbol>, Integer> - raw prefix reference counts
+      @state = :empty
+    end
+
+    def empty?
+      @state == :empty
+    end
+
+    def finalized?
+      @state == :frozen
+    end
+
+    # Add a constant definition using TypeProf's static_cpath
+    def add_definition_with_path(static_cpath, definition_type:)
+      raise "Cannot add definitions when finalized" if finalized?
+      @state = :collecting if empty?
+
+      return if @mappings.key?(static_cpath)
+
+      name = static_cpath.last
+      scope_path = static_cpath[0...-1]
+
+      info = ConstantInfo.new(
+        original_name: name,
+        full_path: static_cpath,
+        definition_type: definition_type,
+        scope_path: scope_path
+      )
+      @mappings[static_cpath] = info
+
+      # Also index by simple name for backward compatibility
+      (@by_name[name] ||= []) << info
+    end
+
+    # Increment usage count for a constant by static_cpath
+    def increment_usage_by_path(static_cpath)
+      raise "Cannot increment usage when finalized" if finalized?
+      return unless @mappings.key?(static_cpath)
+
+      info = @mappings[static_cpath]
+      info.usage_count += 1
+    end
+
+    # Increment usage count by simple name (finds first match)
+    def increment_usage(name)
+      raise "Cannot increment usage when finalized" if finalized?
+      return unless @by_name.key?(name)
+
+      # Increment all constants with this name
+      @by_name[name].each do |info|
+        info.usage_count += 1
+      end
+    end
+
+    def exclude_path(static_cpath)
+      raise "Cannot exclude when finalized" if finalized?
+      info = @mappings.delete(static_cpath)
+      return unless info
+      name = static_cpath.last
+      @by_name[name]&.reject! { |i| i.full_path == static_cpath }
+    end
+
+    # Freeze the mapping and assign short names.
+    # Unified allocation: internal constants and external prefixes are merged
+    # into a single sorted list and allocated from the same NameGenerator.
+    # This follows the src.dest two-phase model: propagation (this method)
+    # determines ALL short names before any application.
+    def assign_short_names(name_generator, skip_class_modules: false)
+      raise "Already finalized" if finalized?
+
+      @state = :frozen
+      prefix_counts = @prefix_counts
+      @prefix_counts = nil
+
+      existing_names = @mappings.each_value.with_object(Set.new) { |info, s| s << info.original_name.to_s }
+
+      # Augment prefix counts with preamble-induced parent refs:
+      # each prefix's declaration (e.g., C5=RuboCop::Cop) references its parent.
+      # Adding unconditionally avoids the chicken-and-egg problem of needing to
+      # know which children are aliased before counting parent refs.
+      prefix_counts.keys.each do |prefix|
+        next if prefix.size < 2
+        prefix_counts[prefix[0...-1]] += 1
+      end
+
+      # Build unified allocation list: [gross_savings_estimate, :internal/:external, object]
+      entries = [] #: Array[[Integer, Symbol, untyped]]
+
+      @mappings.each_value do |info|
+        next if skip_class_modules && info.definition_type != :value
+        next if info.definition_type != :value && external_class_root?(info.full_path)
+        entries << [info.original_name.to_s.size * (info.usage_count + 1), :internal, info]
+      end
+
+      prefix_counts.each do |prefix, count|
+        prefix_string = prefix.map(&:to_s).join('::')
+        info = ExternalPrefixInfo.new(prefix_path: prefix, prefix_string: prefix_string, usage_count: count)
+        entries << [prefix_string.size * count, :external, info]
+      end
+
+      entries.sort_by! { |e| -e[0] }
+
+      # candidate is assigned on the first iteration and only replaced after
+      candidate = nil #: String?
+      entries.each do |_savings, kind, info|
+        if candidate.nil?
+          candidate = name_generator.next_name
+          candidate = name_generator.next_name while existing_names.include?(candidate)
+        end
+        cand = candidate #: String
+
+        case kind
+        when :internal
+          # Kept names make re-minification a fixed point: the names this
+          # pass assigns are themselves KEPT_NAME_MAX or shorter, and a
+          # second pass must not shuffle them again.
+          next if info.original_name.to_s.size <= NameGenerator::KEPT_NAME_MAX
+          next unless info.original_name.to_s.size - cand.size > 0
+          info.short_name = cand
+          @used_short_names << cand
+
+        when :external
+          saved_per_use = info.prefix_string.size - cand.size
+          next unless saved_per_use > 0
+          declaration_cost = cand.size + 1 + info.prefix_string.size + 1
+          net_savings = (saved_per_use * info.usage_count) - declaration_cost
+          next unless net_savings > 0
+          info.short_name = cand
+          info.char_savings = net_savings
+          existing_names << cand
+          @external_prefixes[info.prefix_path] = info
+        end
+
+        candidate = nil
+      end
+    end
+
+    # Generate backward-compatible alias declarations for renamed constants.
+    # Returns array of strings like "OriginalName=ShortName" or
+    # "ShortParent::OriginalName=ShortParent::ShortName" for nested constants.
+    def generate_alias_declarations
+      renamed = @mappings.values.select(&:short_name).sort_by { |info| [info.full_path.size, info.full_path] }
+      renamed.filter_map { |info| build_alias_declaration(info) }
+    end
+
+    # Get short name for a constant by static_cpath. The parameter is nilable
+    # for the callers that pass sliced sub-paths; a nil key simply misses.
+    def short_name_for_path(static_cpath)
+      info = static_cpath ? @mappings[static_cpath] : nil
+      info&.short_name
+    end
+
+    # Get short name for a constant by simple name (finds first match)
+    # Used when static_cpath is not available
+    def short_name_for(name)
+      return nil unless @by_name.key?(name)
+      infos = @by_name[name]
+      return nil if infos.empty?
+      # Return first match (for backward compatibility)
+      infos.first&.short_name
+    end
+
+    # Check if a constant is user-defined by static_cpath
+    def user_defined_path?(static_cpath)
+      @mappings.key?(static_cpath)
+    end
+
+    # Get usage count for a constant by static_cpath
+    def usage_count_for_path(static_cpath)
+      info = @mappings[static_cpath]
+      info ? info.usage_count : 0
+    end
+
+    # Set usage count for a constant by static_cpath
+    def set_usage_count_by_path(static_cpath, count)
+      raise "Cannot set usage when finalized" if finalized?
+      info = @mappings[static_cpath]
+      info.usage_count = count if info
+    end
+
+    # Iterate over user-defined constant paths
+    def each_user_defined_path(&block)
+      @mappings.each_key(&block)
+    end
+
+    # Check if a path is a class or module definition
+    def class_or_module_path?(static_cpath)
+      return false unless static_cpath
+      info = @mappings[static_cpath]
+      info && (info.definition_type == :class || info.definition_type == :module)
+    end
+
+    # Check if any sub-prefix of the path is user-defined
+    def has_user_defined_prefix?(full_path)
+      (1...full_path.size).any? { |i| user_defined_path?(full_path[0...i]) }
+    end
+
+    # Add an external prefix reference count (e.g., [:TypeProf, :Core, :AST] with count 20)
+    def add_external_prefix(prefix_path, usage_count:)
+      raise "Cannot add external prefix when finalized" if finalized?
+      @state = :collecting if empty?
+      @prefix_counts[prefix_path] += usage_count
+    end
+
+    # Get short name for the prefix of a full external path
+    def short_name_for_prefix(full_path)
+      return nil if full_path.nil? || full_path.size < 2
+      prefix = full_path[0...-1] #: Array[Symbol]
+      info = @external_prefixes[prefix]
+      info&.short_name
+    end
+
+    # Generate prefix declaration statements (e.g., ["Z=TypeProf::Core::AST"])
+    # Uses chained aliases when a sub-prefix is also aliased
+    def generate_prefix_declarations
+      sorted = @external_prefixes.values.sort_by { |info| [info.prefix_path.size, -info.char_savings] }
+
+      alias_map = {} #: Hash[Array[Symbol], String?]
+      sorted.map do |info|
+        decl_rhs = info.prefix_string
+        (info.prefix_path.size - 1).downto(2) do |len|
+          sub = info.prefix_path[0...len] #: Array[Symbol]
+          if alias_map.key?(sub)
+            rest = info.prefix_path[len..] #: Array[Symbol]
+            decl_rhs = "#{alias_map[sub]}::#{rest.map(&:to_s).join('::')}"
+            break
+          end
+        end
+        alias_map[info.prefix_path] = info.short_name
+        "#{info.short_name}=#{decl_rhs}"
+      end
+    end
+
+    private
+
+    # A class/module definition whose root the program didn't create is a
+    # reopening (e.g. `class Array`, or `module Prism` adding to the gem) and
+    # must not be renamed. With boot_roots the judgement is exact for the
+    # program's own runtime; without it, fall back to probing this process.
+    def external_class_root?(cpath)
+      return runtime_constant?(cpath) if @boot_roots.nil?
+
+      @boot_roots.include?(cpath.first)
+    end
+
+    # Check if a constant path already exists in the Ruby runtime.
+    # Used to detect class/module reopenings (e.g., `class Array` adding methods
+    # to a built-in class) which must not be renamed.
+    def runtime_constant?(cpath)
+      cpath.reduce(Object) do |mod, name|
+        return false unless mod.is_a?(Module) && mod.const_defined?(name, false)
+        mod.const_get(name, false)
+      end
+      true
+    rescue
+      false
+    end
+
+    # Build backward alias declaration for renamed value constants.
+    # Class/module constants are never renamed (no short_name assigned).
+    def build_alias_declaration(info)
+      path = info.full_path
+      # LHS: short parent path + original leaf name
+      lhs = path.each_index.map { |i|
+        if i < path.size - 1
+          short_name_for_path(path[0..i]) || path[i].to_s
+        else
+          path[i].to_s
+        end
+      }.join('::')
+      # RHS: full short path
+      rhs = path.each_index.map { |i|
+        short_name_for_path(path[0..i]) || path[i].to_s
+      }.join('::')
+      lhs == rhs ? nil : "#{lhs}=#{rhs}"
+    end
+  end
+
+end