ryac 0.2.0

data/lib/ryac/errors.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+# The error hierarchy lives in its own required file, not in ryac.rb:
+# superclass references execute at load, and the concatenated self-host
+# artifact places dependencies first and the root file's own body last —
+# a class defined in the root body can never be a parent for a class
+# defined in a required file.
+module Ryac
+  class Error < StandardError; end
+
+  # The program being minified is at fault — fix the input.
+  class InputError < Error; end
+
+  # ryac itself is at fault — please report it.
+  class InternalError < Error; end
+
+  # The input uses a construct minification cannot handle.
+  class MinifyError < InputError; end
+
+  # The input does not parse. Carries the coordinates of the first error.
+  class SyntaxError < InputError
+    attr_reader :path, :line, :column
+
+    def initialize(message, path: nil, line: nil, column: nil)
+      @path = path
+      @line = line
+      @column = column
+      message = "#{path}:#{line}:#{column}: #{message}" if path
+      super(message)
+    end
+  end
+end

data/lib/ryac/gem_resolver.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Ryac
+  class GemResolver
+    GemResolution = Data.define(:entry_path, :project_root, :require_paths)
+
+    # The one spelling of "minify these installed gems": folds each gem's
+    # resolution into the Minifier#call keyword arguments, so the CLI and
+    # anything replicating it assemble the same invocation.
+    def self.minifier_args(gem_names)
+      resolver = new
+      resolutions = gem_names.map { |name| resolver.call(name) }
+      entry = resolutions.map(&:entry_path)
+      entry = entry[0] if entry.size == 1
+      {
+        entry: entry,
+        project_root: resolutions.map(&:project_root),
+        gem_require_paths: resolutions.flat_map(&:require_paths),
+      }
+    end
+
+    def call(gem_name)
+      spec = Gem::Specification.find_by_name(gem_name)
+      entry_path = find_entry_file(spec, gem_name)
+      raise Pipeline::GemNotFoundError.new(gem_name) unless entry_path
+
+      GemResolution.new(
+        entry_path: entry_path,
+        project_root: spec.gem_dir,
+        require_paths: spec.full_require_paths
+      )
+    rescue Gem::MissingSpecError
+      raise Pipeline::GemNotFoundError.new(gem_name)
+    end
+
+    private
+
+    def find_entry_file(spec, gem_name)
+      candidates = [
+        gem_name,                  # json
+        gem_name.tr('-', '_'),     # concurrent-ruby -> concurrent_ruby
+        gem_name.tr('-', '/'),     # unicode-display_width -> unicode/display_width
+      ].uniq
+
+      spec.full_require_paths.each do |dir|
+        candidates.each do |name|
+          path = File.join(dir, "#{name}.rb")
+          return path if File.exist?(path)
+        end
+      end
+
+      nil
+    end
+  end
+end

data/lib/ryac/minifier.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+require_relative 'pipeline/stage'
+require_relative 'pipeline/data_types'
+require_relative 'pipeline/errors'
+require_relative 'pipeline/file_collector'
+require_relative 'pipeline/concatenator'
+require_relative 'pipeline/analyzer'
+require_relative 'pipeline/source_patcher'
+require_relative 'pipeline/compactor'
+require_relative 'pipeline/boolean_shorten'
+require_relative 'pipeline/char_shorten'
+require_relative 'pipeline/spelling_shorten'
+require_relative 'pipeline/constant_fold'
+require_relative 'pipeline/control_flow_simplify'
+require_relative 'pipeline/endless_method'
+require_relative 'pipeline/paren_optimizer'
+require_relative 'pipeline/rename_patcher'
+require_relative 'pipeline/stage_runner'
+require_relative 'pipeline/constant_aliaser'
+require_relative 'pipeline/attr_decl_shorten'
+require_relative 'pipeline/variable_renamer'
+require_relative 'pipeline/method_renamer'
+
+module Ryac
+  class Minifier
+    # Stage lists are ordered — phase is list position. The optimizers that
+    # run before the rename batch:
+    OPTIMIZE_PRE = [
+      # ControlFlowSimplify must precede EndlessMethod: a def body has to
+      # collapse to a single statement before the def can become endless.
+      [Pipeline::ControlFlowSimplify],
+      [Pipeline::EndlessMethod],
+      [Pipeline::ConstantFold],
+      [Pipeline::BooleanShorten],
+      [Pipeline::CharShorten],
+      [Pipeline::SpellingShorten],
+    ].freeze
+
+    # Paren removal reasons about the final spelling of every call, so it
+    # runs after all renames.
+    OPTIMIZE_POST = [
+      [Pipeline::ParenOptimizer],
+    ].freeze
+
+    DEFAULT_LEVEL = :stable
+
+    def self.resolve_level(value)
+      level = value.to_sym
+      return level if STAGES.key?(level)
+
+      raise ArgumentError, "Invalid compress level: #{value} (valid: #{STAGES.keys.join(', ')})"
+    end
+
+    ALL_VAR_FEATURES = { features: { keywords: true, ivars: true, cvars: true, gvars: true } }.freeze
+    ALL_VAR_WITH_ATTR = { features: { keywords: true, ivars: true, cvars: true, gvars: true, attr_ivars: true } }.freeze
+
+    # :unstable is derived from :stable, never hand-copied — the superset
+    # law lives here as code. "attrs renamed" is one fact spelled by three
+    # co-moving switches: AttrDeclShorten rename_attrs (declarations),
+    # attr_ivars (backing ivars) and MethodRenamer (call sites). This
+    # transform flips all three together; a hand-composed list must too.
+    def self.derive_unstable(stable)
+      stable.flat_map do |entry|
+        if entry[0].equal?(Pipeline::AttrDeclShorten)
+          [[Pipeline::AttrDeclShorten, { rename_attrs: true }]] #: Array[stage_entry]
+        elsif entry[0].equal?(Pipeline::VariableRenamer)
+          [[Pipeline::VariableRenamer, ALL_VAR_WITH_ATTR], [Pipeline::MethodRenamer]] #: Array[stage_entry]
+        else
+          [entry]
+        end
+      end.freeze
+    end
+
+    # The two levels, named for their promise rather than a number.
+    #
+    # :stable is the boundary the optcarrot test certifies frame-for-frame on
+    # a real program: everything up to class, constant and variable renaming,
+    # which closed-world analysis can keep sound.
+    #
+    # :unstable adds method renaming, which a program can defeat by
+    # construction — names survive inside strings, eval'd source and computed
+    # send targets, out of reach of any static analysis. It is certified by
+    # self-hosting and works only when the program plays along.
+    #
+    # Finer configurations are not levels: individual steps stay composable
+    # by passing an explicit stage list in place of a level name.
+    STABLE_STAGES = [
+      *OPTIMIZE_PRE,
+      [Pipeline::ConstantAliaser, { rename_classes: true }],
+      [Pipeline::AttrDeclShorten],
+      [Pipeline::VariableRenamer, ALL_VAR_FEATURES],
+      *OPTIMIZE_POST,
+    ].freeze
+
+    STAGES = {
+      stable: STABLE_STAGES,
+      unstable: derive_unstable(STABLE_STAGES),
+    }.freeze
+
+    # code is raw (uncompacted) text — compaction is the runner's fixed
+    # first step, so every stage list starts from the same dialect.
+    def self.run_stages(code, stages, stdlib_requires: [], rbs_files: {})
+      Pipeline::StageRunner.new(stdlib_requires: stdlib_requires, rbs_files: rbs_files)
+                           .call(code, stages)
+    end
+
+    include Pipeline::SourcePatcher
+
+    attr_reader :result
+
+    def initialize
+      @file_collector = Pipeline::FileCollector.new
+      @concatenator = Pipeline::Concatenator.new
+    end
+
+    def call(entry_path, level: DEFAULT_LEVEL, project_root: nil, gem_names: [], gem_require_paths: [])
+      graph = @file_collector.call(entry_path, project_root: project_root, gem_names: gem_names, gem_require_paths: gem_require_paths)
+      source = @concatenator.call(graph)
+      # Captured while the boundaries still describe the text; from
+      # compaction on they are input provenance, not current positions.
+      file_count = source.file_boundaries.size
+
+      result = run_pipeline(source, level)
+      build_result(result, source, file_count)
+    end
+
+    private
+
+    # target_level is a preset name, or — for callers composing their own
+    # pipeline out of steps — an explicit stage list.
+    def run_pipeline(source, target_level)
+      stages = target_level.is_a?(Array) ? target_level : STAGES.fetch(self.class.resolve_level(target_level))
+      self.class.run_stages(source.content, stages,
+        stdlib_requires: source.stdlib_requires,
+        rbs_files: source.rbs_files
+      )
+    end
+
+    def build_result(rename_result, source, file_count)
+      content = build_output(rename_result.code, source.stdlib_requires, rename_result.preamble)
+      # code and aliases were verified at the runner's exit; the assembled
+      # content is the one string the runner never sees.
+      verify_parses(content, 'content')
+      size = content.bytesize
+
+      stats = Pipeline::CompressionStats.new(
+        original_size: source.original_size,
+        minified_size: size,
+        compression_ratio: size.to_f / source.original_size,
+        file_count: file_count
+      )
+
+      @result = Pipeline::MinifiedResult.new(
+        content: content,
+        aliases: rename_result.aliases,
+        preamble: rename_result.preamble,
+        stats: stats
+      )
+    end
+
+    def build_output(code, stdlib_requires, preamble = '')
+      parts = stdlib_requires.map { |lib| "require \"#{lib}\"" }
+      parts << preamble unless preamble.empty?
+      parts << code
+      parts.join(';')
+    end
+  end
+end

data/lib/ryac/name_generator.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Ryac
+  # Generates sequential short names for variable mangling
+  # a, b, ..., z, a0, a1, ..., z9, a0a, a0b, ..., z9z, ...
+  class NameGenerator
+    LETTERS = ('a'..'z').to_a.freeze
+    DIGITS = ('0'..'9').to_a.freeze
+
+    # A one- or two-character name is as short as this generator's own
+    # output; the rename families keep such names untouched, so a second
+    # minification pass reassigns nothing and the output is a fixed point.
+    KEPT_NAME_MAX = 2
+
+    # additional_excluded holds FINAL names — prefix and case included —
+    # which is what every caller has in hand (kept originals, reserved
+    # names). Comparing before prefixing would make seeding useless to the
+    # prefixed families and force each to re-check by hand.
+    def initialize(additional_excluded = [], prefix: "", upcase: false)
+      @index = 0
+      @prefix = prefix
+      @upcase = upcase
+      @excluded = Set.new(additional_excluded)
+    end
+
+    def next_name
+      loop do
+        name = index_to_name(@index)
+        @index += 1
+        name = name.upcase if @upcase
+        final = "#{@prefix}#{name}"
+        next if @excluded.include?(final)
+        return final
+      end
+    end
+
+    private
+
+    # Convert index to name using letter-digit alternating scheme:
+    # a-z, a0-z9, a0a-z9z, a0a0-z9z9, ...
+    def index_to_name(index)
+      return LETTERS[index] if index < 26
+
+      index -= 26
+      length = 2
+      capacity = 26 * 10
+
+      while index >= capacity
+        index -= capacity
+        length += 1
+        capacity *= (length.odd? ? 26 : 10)
+      end
+
+      result = ""
+      (length - 1).downto(0) do |pos|
+        if pos.even?
+          result = LETTERS[index % 26] + result
+          index /= 26
+        else
+          result = DIGITS[index % 10] + result
+          index /= 10
+        end
+      end
+      result
+    end
+
+  end
+end

data/lib/ryac/pipeline/analyzer.rb

@@ -0,0 +1,264 @@
+# frozen_string_literal: true
+
+require 'stringio'
+
+module Ryac
+  module Pipeline
+    # Stage 3: Analysis
+    # Parses source with TypeProf, builds scope mappings,
+    # collects constants and their references, and freezes mappings.
+    class Analyzer
+      include AnalysisPhases
+
+      def self.prism_only(source)
+        prism_only_from_string(source.content, source: source)
+      end
+
+      def self.prism_only_from_string(content, source: nil)
+        prism_result = Prism.parse(content)
+
+        analyzer = new
+        syntax_data = analyzer.syntax_data_for(prism_result.value)
+
+        source ||= ConcatenatedSource.new(content: content)
+
+        AnalysisResult.new(
+          prism_ast: prism_result.value,
+          scope_mappings: {},
+          constant_mapping: nil,
+          rename_map: {},
+          method_alias_map: {},
+          method_transform_map: {},
+          source: source,
+          attr_rename_map: {},
+          block_param_names_map: {},
+          syntax_data: syntax_data,
+          const_resolution_map: {},
+          const_full_path_map: {},
+          const_write_cpath_map: {},
+          class_cpath_map: {},
+          superclass_resolution_map: {},
+          meta_node_map: {}
+        )
+      end
+
+      def call(source)
+        prism_result, @oracle = without_stdout_pollution { setup_typeprof(source) }
+        @prism_root = prism_result.value
+        @boot_constant_roots = BootConstants.for(source.stdlib_requires)
+        @syntax_data = collect_syntax_data(@prism_root)
+
+        analyze_keywords_and_scopes
+        analyze_methods_phase
+        method_alias_map, method_transform_map = resolve_method_aliases_and_transforms(@prism_root)
+        analyze_variables_phase
+
+        rename_map = @method_rename_mapping.node_mapping.dup
+        attr_ivar_entries = {} #: Hash[location_key, String]
+        attr_rename_map = coordinate_attr_renames(@prism_root, rename_map, attr_ivar_entries)
+
+        analyze_constants_phase
+        local_rename_entries = precompute_rename_entries
+        precompute_constant_resolution
+        precompute_meta_nodes
+
+        build_analysis_result(
+          prism_result, source, rename_map, method_alias_map, method_transform_map,
+          attr_rename_map, attr_ivar_entries, local_rename_entries
+        )
+      end
+
+      def syntax_data_for(prism_ast)
+        collect_syntax_data(prism_ast)
+      end
+
+      private
+
+      # TypeProf prints diagnostics for node types it does not recognize
+      # straight to stdout, which is also where the minified program is
+      # written. Divert anything it emits to stderr so it can never end up
+      # inside the output.
+      def without_stdout_pollution
+        original = $stdout
+        capture = StringIO.new
+        $stdout = capture
+        begin
+          yield
+        ensure
+          $stdout = original
+          noise = capture.string
+          $stderr.print(noise) unless noise.empty?
+        end
+      end
+
+      def setup_typeprof(source)
+        prism_result = Prism.parse(source.content)
+        # Every input file was parse-checked at collection, so a failure
+        # here means an upstream stage broke the text.
+        unless prism_result.errors.none?
+          raise InvalidOutputError.new('pre-rename source', prism_result.errors)
+        end
+
+        [prism_result, TypeOracle.boot(source.content, source.rbs_files)]
+      end
+
+      def analyze_keywords_and_scopes
+        @local_scopes = LocalScopes.new(@prism_root)
+
+        @keyword_rename_mapping = KeywordRenameMapping.new
+        collect_keyword_info(@prism_root)
+        @keyword_rename_mapping.assign_short_names
+
+        # Inline rather than through locals: a local passed as the same-named
+        # keyword gets hint-aligned and collapses to shorthand, and the
+        # re-minified form of that shorthand no longer carries the hint — the
+        # names then oscillate between passes instead of reaching a fixed
+        # point under self-hosting.
+        @local_scopes.allocate(
+          kw_def_map: @keyword_rename_mapping.def_node_mapping(@keyword_def_node_registry || {}),
+          var_hints: @keyword_rename_mapping.build_variable_hints { |val_node| @local_scopes.scope_id_of(val_node) }
+        )
+        @local_scopes.resolve
+        @scope_mappings = @local_scopes.scope_mappings
+      end
+
+      def analyze_methods_phase
+        @method_rename_mapping = MethodRenameMapping.new
+        collect_method_definitions(@prism_root)
+        resolve_method_calls
+        collect_alias_undef_methods(@prism_root)
+        scan_dynamic_method_references(@prism_root)
+        collect_visibility_modifier_methods(@prism_root)
+        collect_attr_write_exclusions(@prism_root)
+        collect_shorthand_pun_methods(@prism_root)
+        @method_rename_mapping.assign_short_names(@scope_mappings, @oracle)
+      end
+
+      def analyze_variables_phase
+        @ivar_rename_mapping = SiteBucketMapping.new(prefix: '@')
+        attr_backed = collect_attr_backed_ivars(@prism_root)
+        collect_ivar_definitions(@prism_root, attr_backed)
+        scan_dynamic_ivar_access(@prism_root)
+        merge_inherited_ivars
+        reserve_attr_ivar_names(@prism_root)
+        @ivar_rename_mapping.assign_short_names
+
+        @cvar_rename_mapping = SiteBucketMapping.new(prefix: '@@')
+        collect_cvar_definitions(@prism_root)
+        scan_dynamic_cvar_access(@prism_root)
+        merge_inherited_cvars
+        @cvar_rename_mapping.assign_short_names
+
+        @gvar_rename_mapping = GvarRenameMapping.new
+        collect_gvar_definitions(@prism_root)
+        scan_alias_globals(@prism_root)
+        @gvar_rename_mapping.assign_short_names
+      end
+
+      def analyze_constants_phase
+        @constant_mapping = ConstantRenameMapping.new(boot_roots: @boot_constant_roots)
+        collect_constants(@prism_root)
+        exclude_private_constants(@prism_root)
+        count_constant_references(@prism_root)
+        augment_constant_counts_via_oracle
+        collect_external_references(@prism_root)
+      end
+
+      def precompute_rename_entries
+        @local_scopes.def_param_names.each do |key, names|
+          (@syntax_data[key] ||= {})[:param_names] = names
+        end
+        @local_scopes.for_index_names.each do |key, name|
+          data = @syntax_data[key]
+          data[:for_index_mangled] = name if data&.[](:index_name)
+        end
+        @block_param_names_map = @local_scopes.block_param_names
+        @local_scopes.rename_entries
+      end
+
+      def build_analysis_result(prism_result, source, rename_map, method_alias_map,
+                                method_transform_map, attr_rename_map, attr_ivar_entries,
+                                local_rename_entries)
+        AnalysisResult.new(
+          prism_ast: prism_result.value,
+          scope_mappings: @scope_mappings,
+          constant_mapping: @constant_mapping,
+          rename_map: rename_map,
+          method_alias_map: method_alias_map,
+          method_transform_map: method_transform_map,
+          source: source,
+          attr_rename_map: attr_rename_map,
+          block_param_names_map: @block_param_names_map,
+          syntax_data: @syntax_data,
+          const_resolution_map: @const_resolution_map,
+          const_full_path_map: @const_full_path_map,
+          const_write_cpath_map: @const_write_cpath_map,
+          class_cpath_map: @class_cpath_map,
+          superclass_resolution_map: @superclass_resolution_map,
+          meta_node_map: @meta_node_map,
+          local_rename_entries: local_rename_entries,
+          keyword_rename_entries: @keyword_rename_mapping.node_mapping,
+          ivar_rename_entries: @ivar_rename_mapping.node_mapping,
+          attr_ivar_entries: attr_ivar_entries,
+          cvar_rename_entries: @cvar_rename_mapping.node_mapping,
+          gvar_rename_entries: @gvar_rename_mapping.node_mapping
+        )
+      end
+
+      META_CALL_METHODS = %i[include attr_reader attr_accessor].freeze
+
+      # Calls the renamer rewrites structurally instead of as plain calls.
+      def precompute_meta_nodes
+        @meta_node_map = {}
+        Nesting.each_meta_call(@prism_root, META_CALL_METHODS) do |call_node, _cpath, _singleton|
+          case call_node.name
+          when :attr_reader, :attr_accessor
+            next unless call_node.arguments
+
+            @meta_node_map[AstUtils.location_key(call_node)] =
+              { type: call_node.name, args: AstUtils.symbol_arguments(call_node) }
+          when :include
+            @meta_node_map[AstUtils.location_key(call_node)] = { type: :include }
+          end
+        end
+      end
+
+      def collect_syntax_data(prism_ast)
+        data = {} #: syntax_data_map
+        traverse_prism(prism_ast, data)
+        data
+      end
+
+      def traverse_prism(node, data)
+        key = AstUtils.line_col_key(node)
+        case node
+        when Prism::DefNode
+          data[key] = { self_receiver: node.receiver.is_a?(Prism::SelfNode) }
+        when Prism::ArrayNode
+          data[key] = { opening: node.opening }
+        when Prism::RangeNode
+          data[key] = { exclude_end: node.exclude_end? }
+        when Prism::RegularExpressionNode
+          data[key] = { content: node.content, flags: node.closing.delete("/") }
+        when Prism::InterpolatedRegularExpressionNode
+          data[key] = { flags: node.closing.delete("/") }
+        when Prism::ForNode
+          idx = node.index
+          if idx.is_a?(Prism::LocalVariableTargetNode)
+            data[key] = { index_name: idx.name }
+          else
+            data[key] = { index_slice: idx.slice }
+          end
+        when Prism::DefinedNode
+          data[key] = { value_slice: node.value.slice }
+        when Prism::RationalNode, Prism::ImaginaryNode, Prism::LambdaNode,
+             Prism::MatchLastLineNode, Prism::InterpolatedMatchLastLineNode,
+             Prism::FlipFlopNode, Prism::AliasGlobalVariableNode,
+             Prism::BackReferenceReadNode
+          data[key] = { slice: node.slice }
+        end
+        node.compact_child_nodes.each { |child| traverse_prism(child, data) }
+      end
+    end
+  end
+end

data/lib/ryac/pipeline/attr_decl_shorten.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Ryac
+  module Pipeline
+    # `attr_reader :a` → `attr :a` (the same method, four bytes shorter) and
+    # single-name attr_accessor → the two-argument attr form, for declarations
+    # type analysis recognized as meta calls. This stage owns the attr rewrite
+    # at every level: with rename_attrs the declared symbols are additionally
+    # mapped through the analysis' attr rename map, keeping declarations in
+    # sync with call sites the method renamer renames.
+    class AttrDeclShorten < Stage
+      include RenamePatcher
+
+      def needs_analysis? = true
+
+      def initialize(rename_attrs: false)
+        @rename_attrs = rename_attrs
+      end
+
+      def collect(ctx, patches)
+        analysis = analysis(ctx)
+        attr_rename_map = analysis.attr_rename_map if @rename_attrs
+        walk_prism(ctx.ast) do |subnode|
+          next unless subnode.is_a?(Prism::CallNode)
+
+          key = prism_location_key(subnode)
+          meta = analysis.meta_node_map[key]
+          next unless meta
+
+          args = meta[:args] || []
+          next unless args.any?
+
+          names = args.map { |sym| attr_rename_map&.dig(key, sym) || sym.to_s }
+          replacement = render_attr_declaration(meta[:type], names)
+          next unless replacement && replacement != subnode.slice
+
+          loc = subnode.location
+          patches << { start: loc.start_offset, end: loc.end_offset, replacement: replacement }
+        end
+      end
+
+      private
+
+      # The compact spelling of an attr declaration: attr_reader collapses to
+      # attr, a single-name attr_accessor takes the two-argument attr form, a
+      # multi-name accessor has no shorter spelling.
+      def render_attr_declaration(type, names)
+        case type
+        when :attr_reader
+          "attr #{names.map { |n| ":#{n}" }.join(',')}"
+        when :attr_accessor
+          if names.size == 1
+            "attr :#{names[0]},!!1"
+          else
+            "attr_accessor #{names.map { |n| ":#{n}" }.join(',')}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ryac/pipeline/boolean_shorten.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Ryac
+  module Pipeline
+    class BooleanShorten < Stage
+      def collect(ctx, patches)
+        walk(ctx.ast, patches)
+      end
+
+      private
+
+      def walk(node, patches, inside_block_params: false)
+        case node
+        when Prism::BlockParametersNode
+          node.compact_child_nodes.each { |child| walk(child, patches, inside_block_params: true) }
+          return
+        when Prism::TrueNode
+          patches << mk(node, '!!1') unless inside_block_params
+        when Prism::FalseNode
+          patches << mk(node, '!1') unless inside_block_params
+        end
+        node.compact_child_nodes.each { |child| walk(child, patches, inside_block_params: inside_block_params) }
+      end
+    end
+  end
+end

data/lib/ryac/pipeline/char_shorten.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Ryac
+  module Pipeline
+    class CharShorten < Stage
+      def collect(ctx, patches)
+        walk(ctx.ast, patches)
+      end
+
+      private
+
+      def walk(node, patches)
+        if node.is_a?(Prism::StringNode) && node.opening_loc && node.content.match?(/\A[a-zA-Z0-9_]\z/)
+          patches << mk(node, "?#{node.content}")
+        end
+        node.compact_child_nodes.each { |child| walk(child, patches) }
+      end
+    end
+  end
+end