ryac 0.2.0

data/sig/ryac/analysis/method/rename_mapping.rbs

@@ -0,0 +1,82 @@
+module Ryac
+  EXCLUDED_METHODS: Set[Symbol]
+
+  type method_key = [Array[Symbol], bool, Symbol]
+
+  class MethodRenameMapping
+    MIN_GROUP_SAVINGS: Integer
+    include UnionFind[method_key]
+
+    type class_key = [Array[Symbol], bool]
+    type method_data = { def_nodes: Array[Prism::Node], call_sites: Array[Prism::Node] }
+    # Both halves optional: assign_short_names substitutes {} when no oracle
+    # is given.
+    type hierarchy = { ?includers: Hash[class_key, Set[class_key]], ?ancestors: Hash[class_key, Array[class_key]] }
+
+    class MethodGroupEntry
+      attr_accessor keys: Array[method_key]
+      attr_accessor original_name: String
+      attr_accessor total_occurrences: Integer
+
+      def initialize: (?Array[method_key]?, ?String?, ?Integer?) -> void
+    end
+
+    @methods: Hash[method_key, method_data]
+    @node_to_key: Hash[Integer, method_key]
+    @node_short_names: Hash[[Integer, Integer], String]
+    @key_short_names: Hash[method_key, String]
+    @implicit_receiver_sites: Hash[Integer, scope_id]
+    @frozen: bool
+
+    def initialize: () -> void
+
+    def add_method: (method_key method_key, Prism::Node? def_node) -> void
+
+    def has_method?: (method_key method_key) -> bool
+
+    def add_call_site: (Prism::Node call_node, method_key method_key, has_receiver: bool, ?scope_id: scope_id?) -> void
+
+    def exclude_methods_by_mid: (Set[Symbol] mids) -> void
+
+    def merge_all_by_mid: (Symbol mid) -> void
+
+    def merge_blind_def_groups: () -> void
+
+    def add_unresolved_sites_for_mid: (Symbol mid, Array[Prism::Node] call_nodes) -> void
+
+    def group_keys: (method_key method_key) -> Array[method_key]
+
+    def each_group_call_site: (method_key method_key) { (Prism::Node, scope_id?) -> void } -> void
+
+    def assign_short_names: (scope_mapping_table scope_mappings, ?TypeOracle? oracle) -> void
+    def verify_no_shadowing!: (?hierarchy hierarchy) -> void
+
+    def short_name_for: ([Integer, Integer] node_location_key) -> String?
+
+    def short_name_for_key: (method_key method_key) -> String?
+
+    def node_mapping: () -> Hash[[Integer, Integer], String]
+
+    def each_method_key: () { (method_key) -> void } -> void
+
+    def method_mids: () -> Set[Symbol]
+
+    def each_cpath_for_mid: (Symbol mid) { (Array[Symbol], bool) -> void } -> void
+
+    private
+
+    def build_group_entries: (Hash[method_key, Array[method_key]] groups) -> Array[MethodGroupEntry]
+
+    def self.build_scope_vars: (scope_mapping_table scope_mappings) -> Hash[scope_id, Set[String]]
+
+    def groups_by_root: () -> Hash[method_key, Array[method_key]]
+
+    def build_existing_method_names: (TypeOracle oracle) -> [Hash[class_key, Set[String]], hierarchy]
+
+    def find_shortest_name: (Array[method_key] keys, Hash[scope_id, Set[String]] scope_vars, Hash[class_key, Set[String]] existing_methods, hierarchy hierarchy) -> String
+
+    def propagate_short_name: (Array[method_key] keys, String short_name, Hash[class_key, Set[String]] existing_methods, hierarchy hierarchy) -> void
+
+    def assign_short_name: (Array[method_key] keys, String short_name) -> void
+  end
+end

data/sig/ryac/analysis/method_aliases.rbs

@@ -0,0 +1,10 @@
+module Ryac
+  KERNEL_ALIASES: Hash[Symbol, Symbol]
+  RECEIVER_ALIASES: Hash[Symbol, Symbol]
+  METHOD_ALIASES: Hash[Symbol, Symbol]
+  METHOD_TRANSFORMS: Hash[[Symbol, Symbol], String]
+  EMPTY_LITERALS: Hash[Symbol, String]
+  SIZE_COMPARISON_OPS: Hash[Symbol, String]
+  SIZE_COMPARISON_TRANSFORMS: Hash[[Symbol, Symbol], String]
+  SIZE_QUERY_MIDS: Hash[Symbol, Array[Symbol]]
+end

data/sig/ryac/analysis/method_aliasing.rbs

@@ -0,0 +1,9 @@
+module Ryac
+  module AnalysisPhases
+    def resolve_method_aliases_and_transforms: (Prism::Node prism_root) -> [Hash[location_key, Symbol], Hash[location_key, String]]
+
+    private
+
+    def register_size_comparison: (Prism::CallNode node, Hash[location_key, String] transform_map, Array[location_key] suppressed_alias_keys) -> void
+  end
+end

data/sig/ryac/analysis/nesting.rbs

@@ -0,0 +1,9 @@
+module Ryac
+  module Nesting
+    def self?.each: (Prism::Node root) { (Prism::Node, Array[Symbol], bool, bool) -> void } -> void
+    def self?.each_meta_call: (Prism::Node root, Array[Symbol] names, ?loose: bool) { (Prism::CallNode, Array[Symbol], bool) -> void } -> void
+    def self?.each_method_definition: (Prism::Node root) { (Prism::DefNode, [Array[Symbol], bool, Symbol]) -> void } -> void
+    def self?.path_segments: (Prism::Node constant_path) -> [Array[Symbol], bool]?
+    def self?.walk: (Prism::Node? node, Array[Symbol] cpath, bool singleton, bool in_def) { (Prism::Node, Array[Symbol], bool, bool) -> void } -> void
+  end
+end

data/sig/ryac/analysis/scope_management.rbs

@@ -0,0 +1,5 @@
+module Ryac
+  module RenameInvariants
+    def verify_injective!: (Hash[Symbol, String] mapping, String scope_label) -> void
+  end
+end

data/sig/ryac/analysis/site_bucket_mapping.rbs

@@ -0,0 +1,26 @@
+module Ryac
+  class SiteBucketMapping
+    @prefix: String
+    @kept_name_max: Integer
+    @buckets: Hash[Array[Symbol], Hash[Symbol, Array[untyped]]]
+    @cpath_to_canonical: Hash[Array[Symbol], Array[Symbol]]
+    @excluded_cpaths: Set[Array[Symbol]]
+    @reserved_names: Hash[Array[Symbol], Set[String]]
+    @node_short_names: Hash[[Integer, Integer], String]
+    @frozen: bool
+
+    def initialize: (prefix: String) -> void
+    def add_site: (Array[Symbol] cpath, Symbol name, untyped node) -> void
+    def exclude_cpath: (Array[Symbol] cpath) -> void
+    def reserve_name: (Array[Symbol] cpath, String short_name) -> void
+    def each_canonical_cpath: () { (Array[Symbol]) -> void } -> void
+    def merge_with_ancestor: (Array[Symbol] child_cpath, Array[Symbol] ancestor_cpath) -> void
+    def assign_short_names: () -> void
+    def node_mapping: () -> Hash[[Integer, Integer], String]
+
+    private
+
+    def check_open!: (String action) -> void
+    def resolve_canonical: (Array[Symbol] cpath) -> Array[Symbol]
+  end
+end

data/sig/ryac/analysis/type_oracle.rbs

@@ -0,0 +1,61 @@
+module Ryac
+  # The TypeProf aliases live with the one class allowed to touch them.
+  type tp_node = TypeProf::Core::AST::Node
+  type tp_genv = TypeProf::Core::GlobalEnv
+
+  class TypeOracle
+    def self.boot: (String content, Hash[String, String] rbs_files) -> TypeOracle
+    def self.raw_prism_node: (tp_node node) -> Prism::Node?
+
+    class CallerInfo
+      attr_accessor prism_node: Prism::Node?
+      attr_accessor super: bool
+      attr_accessor caller_cpath: Array[Symbol]?
+      attr_accessor receiver: bool
+      attr_accessor keyword_entries: Array[[Prism::Node, Prism::Node]]?
+      attr_accessor keyword_splat: bool
+
+      def initialize: (?prism_node: Prism::Node?, ?super: bool, ?caller_cpath: Array[Symbol]?, ?receiver: bool, ?keyword_entries: Array[[Prism::Node, Prism::Node]]?, ?keyword_splat: bool) -> void
+    end
+
+    TP_CALL_NODES: Array[Class]
+
+    @genv: tp_genv
+    @tp_root: tp_node
+    @ancestor_cpaths: Hash[MethodRenameMapping::class_key, Array[Array[Symbol]]]
+    @const_resolution_cache: Hash[location_key, Array[Symbol]?]
+    @method_cache: Hash[method_key, TypeProf::Core::MethodEntity?]
+    # Both built by build_tp_indexes before first read.
+    @tp_calls_by_loc: Hash[location_key, Hash[Symbol, TypeProf::Core::AST::CallBaseNode]]
+    @tp_consts_by_loc: Hash[location_key, TypeProf::Core::AST::ConstantReadNode]
+
+    def initialize: (tp_genv genv, tp_node tp_root) -> void
+
+    def each_ancestor_cpath: (Array[Symbol] cpath, bool singleton) { (Array[Symbol]) -> void } -> void
+    def each_ancestor_methods: (Array[Symbol] cpath, bool singleton) { (Array[Symbol], bool, Array[String]) -> void } -> void
+    def method_known?: (Array[Symbol] cpath, bool singleton, Symbol mid) -> bool
+    def method_defined?: (Array[Symbol] cpath, bool singleton, Symbol mid) -> bool
+    def method_call_count: (Array[Symbol] cpath, bool singleton, Symbol mid) -> Integer
+    def each_call_site_key: (Array[Symbol] cpath, bool singleton, Symbol mid) { (location_key) -> void } -> void
+    def method_definition_keys: (Array[Symbol] cpath, bool singleton, Symbol mid) -> Array[location_key]
+    def each_caller: (Array[Symbol] cpath, bool singleton, Symbol mid) { (CallerInfo) -> void } -> void
+    def resolved_targets: (Prism::Node prism_call_node, Symbol mid) -> Array[method_key]?
+    def first_argument_symbols: (Prism::CallNode prism_call_node) -> Array[Symbol]
+    def receiver_responds_to?: (Prism::CallNode prism_call_node, Symbol mid) -> bool
+    def receiver_within_type?: (Prism::CallNode prism_call_node, Symbol type_name) -> bool
+    def resolve_constant_read: (Prism::Node prism_node) -> Array[Symbol]?
+    def constant_read_count: (Array[Symbol] cpath) -> Integer
+
+    private
+
+    def tp_key: (tp_node node) -> location_key
+    def resolve_method: (Array[Symbol] cpath, bool singleton, Symbol mid) -> untyped
+    def every_receiver_base_type: (Prism::CallNode prism_call_node) { (untyped) -> boolish } -> bool
+    def type_responds_to?: (untyped mod, bool singleton, Symbol mid) -> bool
+    def mod_is_or_inherits?: (untyped mod, untyped target) -> bool
+    def tp_call_for: (Prism::Node prism_node, Symbol mid) -> TypeProf::Core::AST::CallBaseNode?
+    def tp_const_for: (Prism::Node prism_node) -> TypeProf::Core::AST::ConstantReadNode?
+    def build_tp_indexes: () -> void
+    def resolve_tp_const: (tp_node node) -> Array[Symbol]?
+  end
+end

data/sig/ryac/ast_utils.rbs

@@ -0,0 +1,34 @@
+module Ryac
+  module AstUtils
+    def self?.symbol_arguments: (Prism::CallNode call_node) -> Array[Symbol]
+    MIDDLE_METHODS: Array[Symbol]
+    TERNARY_SAFE_PREV: Array[Integer]
+    COMPARISON_PREV: Array[Integer]
+    PIPE_BREAK_BYTES: Array[Integer]
+
+    def self?.unwrap_statements: (Prism::Node? node) -> Prism::Node?
+    def self?.middle_method?: (Symbol method) -> bool
+    def self?.logical_op?: (Prism::Node? node) -> bool
+    def self?.has_block?: (Prism::CallNode node) -> bool
+    def self?.single_statement_body?: (Prism::Node? body) -> bool
+    def self?.setter_def_name?: (Symbol name) -> bool
+    def self?.simple_negatable?: (Prism::Node node) -> bool
+    def self?.first_arg_starts_with_brace?: (Prism::Node arg) -> bool
+    def self?.ends_with_name_char?: (Prism::Node? node) -> bool
+    def self?.ends_with_method_suffix?: (Prism::Node node) -> bool
+    def self?.needs_ternary_q_space?: (Prism::Node node) -> bool
+    def self?.modifier_control_flow?: (Prism::Node node) -> bool
+    def self?.modifier_conditional?: (Prism::Node node) -> bool?
+    def self?.modifier_loop?: (Prism::Node node) -> bool
+    def self?.ternary_needs_parens?: (Prism::Node node, String source) -> bool
+    def self?.can_omit_parens?: (Prism::CallNode node, ?String? method_name) -> bool
+    def self?.first_arg_is_regex?: (Prism::Node arg) -> bool
+    def self?.contains_bare_block?: (Prism::Node? node) -> bool
+    MATCH_REBIND_NODES: Array[untyped]
+    def self?.match_rebind?: (Prism::Node node) -> bool
+    def self?.shorthand_pun_values: (Prism::Node node) -> Array[Prism::Node]
+    def self?.each_node: (Prism::Node? node) { (Prism::Node) -> void } -> void
+    def self?.location_key: (Prism::Node node) -> location_key
+    def self?.line_col_key: (Prism::Node node) -> line_col_key
+  end
+end

data/sig/ryac/errors.rbs

@@ -0,0 +1,21 @@
+module Ryac
+  class Error < StandardError
+  end
+
+  class InputError < Error
+  end
+
+  class InternalError < Error
+  end
+
+  class MinifyError < InputError
+  end
+
+  class SyntaxError < InputError
+    attr_reader path: String?
+    attr_reader line: Integer?
+    attr_reader column: Integer?
+
+    def initialize: (String message, ?path: String?, ?line: Integer?, ?column: Integer?) -> void
+  end
+end

data/sig/ryac/gem_resolver.rbs

@@ -0,0 +1,28 @@
+module Ryac
+  class GemResolver
+    class GemResolution
+      attr_reader entry_path: String
+      attr_reader project_root: String
+      attr_reader require_paths: Array[String]
+
+      def self.new: (entry_path: String, project_root: String, require_paths: Array[String]) -> GemResolution
+    end
+
+    def self.minifier_args: (Array[String] gem_names) -> { entry: String | Array[String], project_root: Array[String], gem_require_paths: Array[String] }
+    def call: (String gem_name) -> GemResolution
+
+    private
+
+    def find_entry_file: (Gem::Specification spec, String gem_name) -> String?
+  end
+end
+
+# The rbs gem's rubygems shim (rbs/sig/shims/rubygems.rbs) declares only the
+# few Gem::Specification methods rbs itself calls; full_require_paths is real
+# rubygems API (Gem::BasicSpecification#full_require_paths) that GemResolver
+# uses, so it is declared here.
+module Gem
+  class Specification
+    def full_require_paths: () -> Array[String]
+  end
+end

data/sig/ryac/minifier.rbs

@@ -0,0 +1,33 @@
+module Ryac
+  class Minifier
+    DEFAULT_LEVEL: Symbol
+
+    type stage_class = singleton(Pipeline::Stage)
+    type stage_entry = [stage_class] | [stage_class, Hash[Symbol, untyped]]
+
+    def self.resolve_level: (String | Symbol value) -> Symbol
+
+    OPTIMIZE_PRE: Array[stage_entry]
+    OPTIMIZE_POST: Array[stage_entry]
+    ALL_VAR_FEATURES: Hash[Symbol, Hash[Symbol, bool]]
+    ALL_VAR_WITH_ATTR: Hash[Symbol, Hash[Symbol, bool]]
+    STABLE_STAGES: Array[stage_entry]
+    STAGES: Hash[Symbol, Array[stage_entry]]
+
+    def self.derive_unstable: (Array[stage_entry] stable) -> Array[stage_entry]
+    def self.run_stages: (String code, Array[stage_entry] stages, ?stdlib_requires: Array[String], ?rbs_files: Hash[String, String]) -> Pipeline::RenameResult
+
+    include Pipeline::SourcePatcher
+
+    attr_reader result: Pipeline::MinifiedResult?
+
+    def initialize: () -> void
+    def call: (String | Array[String] entry_path, ?level: Symbol | Array[stage_entry], ?project_root: String | Array[String] | nil, ?gem_names: Array[String], ?gem_require_paths: Array[String]) -> Pipeline::MinifiedResult
+
+    private
+
+    def run_pipeline: (Pipeline::ConcatenatedSource source, Symbol | Array[stage_entry] target_level) -> Pipeline::RenameResult
+    def build_result: (Pipeline::RenameResult rename_result, Pipeline::ConcatenatedSource source, Integer file_count) -> Pipeline::MinifiedResult
+    def build_output: (String code, Array[String] stdlib_requires, ?String preamble) -> String
+  end
+end

data/sig/ryac/name_generator.rbs

@@ -0,0 +1,14 @@
+module Ryac
+  class NameGenerator
+    LETTERS: Array[String]
+    DIGITS: Array[String]
+    KEPT_NAME_MAX: Integer
+
+    def initialize: (?(Array[String] | Set[String]) additional_excluded, ?prefix: String, ?upcase: bool) -> void
+    def next_name: () -> String
+
+    private
+
+    def index_to_name: (Integer index) -> String
+  end
+end

data/sig/ryac/pipeline/analyzer.rbs

@@ -0,0 +1,34 @@
+module Ryac
+  module Pipeline
+    class Analyzer
+      include AnalysisPhases
+
+      @syntax_data: syntax_data_map
+      # Values are { type: Symbol } or { type: Symbol, args: Array[Symbol] };
+      # kept untyped-valued because syntax_value has no Array member.
+      @meta_node_map: Hash[location_key, meta_node_entry]
+
+      def self.prism_only: (ConcatenatedSource source) -> AnalysisResult
+      def self.prism_only_from_string: (String content, ?source: ConcatenatedSource?) -> AnalysisResult
+      def call: (ConcatenatedSource source) -> AnalysisResult
+      def syntax_data_for: (Prism::ProgramNode prism_ast) -> syntax_data_map
+
+      private
+
+      def without_stdout_pollution: [T] () { () -> T } -> T
+      def setup_typeprof: (ConcatenatedSource source) -> [Prism::ParseResult, TypeOracle]
+      def analyze_keywords_and_scopes: () -> void
+      def analyze_methods_phase: () -> void
+      def analyze_variables_phase: () -> void
+      def analyze_constants_phase: () -> void
+      def precompute_rename_entries: () -> Hash[location_key, String]
+      def build_analysis_result: (Prism::ParseResult prism_result, ConcatenatedSource source, Hash[location_key, String] rename_map, Hash[location_key, Symbol] method_alias_map, Hash[location_key, String] method_transform_map, Hash[location_key, Hash[Symbol, String]] attr_rename_map, Hash[location_key, String] attr_ivar_entries, Hash[location_key, String] local_rename_entries) -> AnalysisResult
+
+      META_CALL_METHODS: Array[Symbol]
+
+      def precompute_meta_nodes: () -> void
+      def collect_syntax_data: (Prism::ProgramNode prism_ast) -> syntax_data_map
+      def traverse_prism: (Prism::Node node, syntax_data_map data) -> void
+    end
+  end
+end

data/sig/ryac/pipeline/attr_decl_shorten.rbs

@@ -0,0 +1,17 @@
+module Ryac
+  module Pipeline
+    class AttrDeclShorten < Stage
+      include RenamePatcher
+
+      @rename_attrs: bool
+
+      def needs_analysis?: () -> bool
+      def initialize: (?rename_attrs: bool) -> void
+      def collect: (StageContext ctx, Array[patch_entry] patches) -> void
+
+      private
+
+      def render_attr_declaration: (Symbol type, Array[String] names) -> String?
+    end
+  end
+end

data/sig/ryac/pipeline/boolean_shorten.rbs

@@ -0,0 +1,11 @@
+module Ryac
+  module Pipeline
+    class BooleanShorten < Stage
+      def collect: (StageContext ctx, Array[patch_entry] patches) -> void
+
+      private
+
+      def walk: (Prism::Node node, Array[patch_entry] patches, ?inside_block_params: bool) -> void
+    end
+  end
+end

data/sig/ryac/pipeline/char_shorten.rbs

@@ -0,0 +1,11 @@
+module Ryac
+  module Pipeline
+    class CharShorten < Stage
+      def collect: (StageContext ctx, Array[patch_entry] patches) -> void
+
+      private
+
+      def walk: (Prism::Node node, Array[patch_entry] patches) -> void
+    end
+  end
+end

data/sig/ryac/pipeline/compactor.rbs

@@ -0,0 +1,125 @@
+module Ryac
+  module Pipeline
+    class Compactor
+      BINARY_OPERATORS: Array[Symbol]
+      NON_ASSOCIATIVE_OPS: Set[Symbol]
+      OPERATOR_PRECEDENCE: Hash[Symbol, Integer]
+      COMPOUND_WRITE_NODES: Array[singleton(Prism::Node)]
+      MODIFIER_KEYWORD_NODES: Array[singleton(Prism::Node)]
+      ASSIGNMENT_NODES: Array[singleton(Prism::Node)]
+      PARENS_KEPT_NODES: Array[singleton(Prism::Node)]
+      PARENS_KEPT_CLASSES: Set[singleton(Prism::Node)]
+      JUMP_NODES: Array[singleton(Prism::Node)]
+      LOGIC_LOOSE_OPERANDS: Array[singleton(Prism::Node)]
+      LOGIC_LOOSE_OPERAND_CLASSES: Set[singleton(Prism::Node)]
+      PERCENT_SAFE_WORD: Regexp
+
+      def self.jump_with_value?: (Prism::Node? node) -> bool
+      def self.loose_logic_operand?: (Prism::Node? node, tight: bool) -> bool
+
+      # The 24 compound-assignment node classes dispatched by r_compound_write
+      # (`+=`-style Operator variants plus `||=`/`&&=` Or/And variants).
+      type compound_write_node = Prism::LocalVariableOperatorWriteNode | Prism::LocalVariableOrWriteNode | Prism::LocalVariableAndWriteNode
+                               | Prism::InstanceVariableOperatorWriteNode | Prism::InstanceVariableOrWriteNode | Prism::InstanceVariableAndWriteNode
+                               | Prism::GlobalVariableOperatorWriteNode | Prism::GlobalVariableOrWriteNode | Prism::GlobalVariableAndWriteNode
+                               | Prism::ClassVariableOperatorWriteNode | Prism::ClassVariableOrWriteNode | Prism::ClassVariableAndWriteNode
+                               | Prism::ConstantOperatorWriteNode | Prism::ConstantOrWriteNode | Prism::ConstantAndWriteNode
+                               | Prism::ConstantPathOperatorWriteNode | Prism::ConstantPathOrWriteNode | Prism::ConstantPathAndWriteNode
+                               | Prism::CallOperatorWriteNode | Prism::CallOrWriteNode | Prism::CallAndWriteNode
+                               | Prism::IndexOperatorWriteNode | Prism::IndexOrWriteNode | Prism::IndexAndWriteNode
+
+      @prism_ast: Prism::ProgramNode
+      GROUP_MIN: Integer
+      @standard_error_redefined: bool?
+
+      def call: (String input_string) -> String
+
+      private
+
+      def rebuild: () -> Array[String]
+      def r: (Prism::Node? node) -> String
+      def r_stmt: (Prism::Node? nodes) -> String
+      def singleton_self_def?: (Prism::Node node) -> bool
+      def render_statement_list: (Array[Prism::Node] stmts) -> Array[String]
+      def flush_singleton_run: (Array[Prism::DefNode] run) -> Array[String]
+      def r_call: (Prism::CallNode node) -> String
+      def r_binary_op: (Prism::CallNode node) -> String
+      def r_block_call: (Prism::CallNode node) -> String?
+      def r_index_access: (Prism::CallNode node) -> String
+      def r_index_assign: (Prism::CallNode node) -> String
+      def r_unary: (Prism::CallNode node, String op) -> String
+      def r_def: (Prism::DefNode node, ?drop_self_receiver: bool) -> String
+      def r_lambda: (Prism::LambdaNode node) -> String
+      def r_yield: (Prism::YieldNode node) -> String
+      def r_if: (Prism::IfNode node) -> String
+      def r_unless: (Prism::UnlessNode node) -> String
+      def r_while: (Prism::WhileNode node) -> String
+      def r_until: (Prism::UntilNode node) -> String
+      def r_case: (Prism::CaseNode node) -> String
+      def r_case_match: (Prism::CaseMatchNode node) -> String
+      def r_in_pattern: (Prism::Node pattern) -> String
+      def r_pattern: (Prism::Node node) -> String
+      def r_for: (Prism::ForNode node) -> String
+      def r_return: (Prism::ReturnNode node) -> String
+      def r_break: (Prism::BreakNode node) -> String
+      def r_alias_name: (Prism::Node node) -> String
+      def r_next: (Prism::NextNode node) -> String
+      def r_jump: (String keyword, Prism::ArgumentsNode? arguments) -> String
+      def r_compound_write: (compound_write_node node) -> String
+      def compound: (String | Symbol target, Symbol | String op, compound_write_node node) -> String
+      def call_target: (Prism::CallOperatorWriteNode | Prism::CallOrWriteNode | Prism::CallAndWriteNode node) -> String
+      def idx_target: (Prism::IndexOperatorWriteNode | Prism::IndexOrWriteNode | Prism::IndexAndWriteNode node) -> String
+      def r_symbol: (Prism::SymbolNode node) -> String
+      def r_regexp: (Prism::RegularExpressionNode node) -> String
+      def escape_regexp_slash: (String content) -> String
+      def r_array: (Prism::ArrayNode node) -> String
+      def percent_array_form: (Prism::ArrayNode node) -> String?
+      def r_float: (Prism::FloatNode node) -> String
+      def r_range: (Prism::RangeNode node, ?bare: bool) -> String
+      def r_delimited: (Prism::Node node) -> String
+      def r_flipflop: (Prism::FlipFlopNode node) -> String
+      def r_hash: (Prism::HashNode node) -> String
+      def r_keyword_hash: (Prism::KeywordHashNode node) -> String
+      def r_assoc: (Prism::AssocNode element) -> String
+      def r_string: (Prism::StringNode node) -> String
+      def r_interp_string: (Prism::InterpolatedStringNode node) -> String
+      def r_interp_symbol: (Prism::InterpolatedSymbolNode node) -> String
+      def r_interp_regexp: (Prism::InterpolatedRegularExpressionNode node) -> String
+      def interp_part: (Prism::Node part, ?escape_quotes: bool) -> String
+      def escape_for_dquote: (String str) -> String
+      def r_class: (Prism::ClassNode node) -> String
+      def r_module: (Prism::ModuleNode node) -> String
+      def r_singleton_class: (Prism::SingletonClassNode node) -> String
+      def r_and: (Prism::AndNode node) -> String
+      def r_or: (Prism::OrNode node) -> String
+      def logic_operand: (Prism::Node operand, tight: bool) -> String
+      def r_begin: (Prism::BeginNode node) -> String
+      def bare_standard_error?: (Array[Prism::node] exceptions) -> bool
+      def standard_error_redefined?: () -> bool
+      def r_super: (Prism::SuperNode node) -> String
+      def r_defined: (Prism::DefinedNode node) -> String
+      def r_multi_write: (Prism::MultiWriteNode node) -> String
+      def r_multi_target: (Prism::Node target) -> String
+      def r_array_pattern: (Prism::ArrayPatternNode node) -> String
+      def r_hash_pattern: (Prism::HashPatternNode node) -> String
+      def r_find_pattern: (Prism::FindPatternNode node) -> String
+      def build_call_args: (Prism::CallNode node, ?String? block_pass) -> String
+      def build_def_params: (Prism::ParametersNode? params) -> Array[String]
+      def r_multi_target_param: (Prism::MultiTargetNode target) -> String
+      def build_lambda_params: (Prism::Node? block_params) -> String
+      def extract_block_params: (Prism::BlockNode block) -> Array[String]
+      def recv_with_op: (Prism::Node? recv_node, String call_op) -> String
+      def wrap_operand: (Prism::Node? node, Symbol parent_op, Symbol side) -> [String, bool]
+      def binary_op_separator: (Prism::Node? recv_node, bool recv_wrapped, Symbol op) -> String
+      def build_if_chain: (Prism::IfNode node) -> String
+      def r_parens: (Prism::ParenthesesNode node) -> String
+      def fmt_body: (String? body) -> String
+      def binary_operator_call?: (Prism::Node? node) -> bool?
+      def setter_call?: (Prism::CallNode node) -> bool?
+      def node_returns_bot?: (Prism::Node node) -> bool
+      def rescue_var_used?: (Prism::RescueNode rescue_node) -> bool
+      def block_uses_it?: (Prism::Node? body) -> bool
+      def prism_traverse: (Prism::Node? node) { (Prism::Node) -> void } -> void
+    end
+  end
+end

data/sig/ryac/pipeline/concatenator.rbs

@@ -0,0 +1,28 @@
+module Ryac
+  module Pipeline
+    class Concatenator
+      class GraphSorter
+        include TSort[String]
+
+        def initialize: (DependencyGraph graph) -> void
+        def tsort_each_node: () { (String) -> void } -> void
+        def tsort_each_child: (String node) { (String) -> void } -> void
+      end
+
+      def call: (DependencyGraph graph) -> ConcatenatedSource
+
+      private
+
+      def topological_sort: (DependencyGraph graph) -> Array[String]
+      def extract_cycle_from_graph: (DependencyGraph graph) -> Array[String]
+      def find_cycle_dfs: (DependencyGraph graph, String node, Set[String] visited, Set[String] rec_stack, Array[String] path) -> bool
+      def concatenate_files: (DependencyGraph graph, Array[String] sorted_paths) -> ConcatenatedSource
+      def collect_stdlib_requires: (FileEntry entry, Array[String] stdlib_requires) -> void
+      def process_require_statements: (FileEntry entry, DependencyGraph graph, Set[String] inlined, Hash[String, String] cleaned_cache) -> String
+      def offset_based_processing: (String content, Array[require_node_info] nodes, DependencyGraph graph, Set[String] in_class_deps, Set[String] inlined, Hash[String, String] cleaned_cache) -> String
+      def line_based_processing: (String content, Array[require_node_info] require_nodes) -> String
+      def resolve_node_path: (require_node_info node, DependencyGraph graph) -> String?
+      def strip_outer_nesting: (String content) -> String
+    end
+  end
+end

data/sig/ryac/pipeline/constant_aliaser.rbs

@@ -0,0 +1,35 @@
+module Ryac
+  module Pipeline
+    class ConstantAliaser < Stage
+      include RenamePatcher
+
+      @class_module_cpath_offsets: Set[Integer]
+      @constant_mapping: ConstantRenameMapping
+      @rename_classes: bool
+
+      def needs_analysis?: () -> bool
+      def initialize: (?rename_classes: bool) -> void
+      def collect: (StageContext ctx, Array[patch_entry] patches) -> void
+      def finish: (StageContext ctx) -> void
+
+      private
+
+      def collect_patches: (Prism::Node node, Array[patch_entry] patches, AnalysisResult analysis) -> void
+
+      # The patch_* helpers are called for their side effects from the
+      # walk_prism block, whose declared result is Symbol? (:skip_children or
+      # nil) — untyped rather than void keeps the block body compatible.
+      def patch_constant_ref: (Prism::ConstantReadNode | Prism::ConstantPathNode node, Array[patch_entry] patches, AnalysisResult analysis) -> untyped
+      def patch_constant_write: (Prism::ConstantWriteNode | Prism::ConstantTargetNode node, Array[patch_entry] patches, AnalysisResult analysis) -> untyped
+      def patch_constant_path_write: (Prism::ConstantPathWriteNode node, Array[patch_entry] patches, AnalysisResult analysis) -> untyped
+      def patch_class_node: (Prism::ClassNode node, Array[patch_entry] patches, AnalysisResult analysis) -> untyped
+      def patch_module_node: (Prism::ModuleNode node, Array[patch_entry] patches, AnalysisResult analysis) -> untyped
+      def patch_definition_path: (Prism::ClassNode | Prism::ModuleNode node, Array[patch_entry] patches, Array[Symbol]? class_cpath, AnalysisResult analysis) -> void
+      def render_short_cpath: (Array[Symbol] cpath, ?from: Integer) -> String
+      def mark_constant_children: (Prism::Node node) -> void
+      def build_renamed_via_user_prefix: (Prism::ConstantPathNode node, AnalysisResult analysis) -> String?
+      def get_short_cpath: (Array[Symbol] cpath) -> String
+      def patch_def_receiver: (Prism::Node receiver, Array[patch_entry] patches, AnalysisResult analysis) -> untyped
+    end
+  end
+end

data/sig/ryac/pipeline/constant_fold.rbs

@@ -0,0 +1,20 @@
+module Ryac
+  module Pipeline
+    class ConstantFold < Stage
+      FOLDABLE_OPS: Array[Symbol]
+      INTEGER_ONLY_OPS: Array[Symbol]
+
+      def collect: (StageContext ctx, Array[patch_entry] patches) -> void
+
+      private
+
+      def walk: (Prism::Node node, Array[patch_entry] patches) -> void
+      def try_constant_fold: (Prism::Node node) -> Numeric?
+      def try_fold_binary_op: (Prism::CallNode node) -> Numeric?
+      # The operands are Integer | Float at runtime, but RBS's Numeric does
+      # not carry the arithmetic operators and the op is dispatched on a
+      # Symbol tag, so the operands stay untyped.
+      def apply_op: (untyped lhs, Symbol op, untyped rhs) -> Numeric?
+    end
+  end
+end