ryac 0.2.0

data/lib/ryac/union_find.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Ryac
+  module UnionFind
+    def uf_init
+      @parent = {}
+      @rank = {}
+    end
+
+    def uf_root(key)
+      @parent[key] = uf_root(@parent[key]) if @parent[key] != key
+      @parent[key]
+    end
+
+    def merge_groups(key1, key2)
+      root1 = uf_root(key1)
+      root2 = uf_root(key2)
+      return if root1 == root2
+
+      if @rank[root1] < @rank[root2]
+        @parent[root1] = root2
+      elsif @rank[root1] > @rank[root2]
+        @parent[root2] = root1
+      else
+        @parent[root2] = root1
+        @rank[root1] += 1
+      end
+    end
+
+    private
+
+    def uf_add(key)
+      @parent[key] ||= key
+      @rank[key] ||= 0
+    end
+
+    def uf_remove(key)
+      @parent.delete(key)
+      @rank.delete(key)
+    end
+  end
+end

data/lib/ryac/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Ryac
+  VERSION = "0.2.0"
+end

data/lib/ryac.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'prism'
+require 'rbconfig'
+
+require_relative "ryac/errors"
+require_relative "ryac/ast_utils"
+require_relative "ryac/version"
+require_relative "ryac/name_generator"
+require_relative "ryac/analysis/method_aliases"
+require_relative "ryac/analysis/constant/rename_mapping"
+require_relative "ryac/analysis/scope_management"
+require_relative "ryac/analysis/local_scopes"
+require_relative "ryac/analysis/nesting"
+require_relative "ryac/analysis/type_oracle"
+require_relative "ryac/analysis/constant/collection"
+require_relative "ryac/analysis/method_aliasing"
+require_relative "ryac/union_find"
+require_relative "ryac/analysis/method/rename_mapping"
+require_relative "ryac/analysis/method/collection"
+require_relative "ryac/analysis/site_bucket_mapping"
+require_relative "ryac/analysis/ivar/collection"
+require_relative "ryac/analysis/cvar/collection"
+require_relative "ryac/analysis/gvar/rename_mapping"
+require_relative "ryac/analysis/gvar/collection"
+require_relative "ryac/analysis/keyword/rename_mapping"
+require_relative "ryac/analysis/keyword/collection"
+require_relative "ryac/minifier"
+require_relative "ryac/gem_resolver"

data/rbs_collection.lock.yaml

@@ -0,0 +1,224 @@
+---
+path: ".gem_rbs_collection"
+gems:
+- name: activesupport
+  version: '7.0'
+  source:
+    type: git
+    name: ruby/gem_rbs_collection
+    revision: 9ab762c8247028f90620fc93c4e7aac20eb693d7
+    remote: https://github.com/ruby/gem_rbs_collection.git
+    repo_dir: gems
+- name: ast
+  version: '2.4'
+  source:
+    type: git
+    name: ruby/gem_rbs_collection
+    revision: 9ab762c8247028f90620fc93c4e7aac20eb693d7
+    remote: https://github.com/ruby/gem_rbs_collection.git
+    repo_dir: gems
+- name: base64
+  version: 0.3.0
+  source:
+    type: rubygems
+- name: bigdecimal
+  version: 4.1.2
+  source:
+    type: rubygems
+- name: concurrent-ruby
+  version: '1.1'
+  source:
+    type: git
+    name: ruby/gem_rbs_collection
+    revision: 9ab762c8247028f90620fc93c4e7aac20eb693d7
+    remote: https://github.com/ruby/gem_rbs_collection.git
+    repo_dir: gems
+- name: connection_pool
+  version: '2.4'
+  source:
+    type: git
+    name: ruby/gem_rbs_collection
+    revision: 9ab762c8247028f90620fc93c4e7aac20eb693d7
+    remote: https://github.com/ruby/gem_rbs_collection.git
+    repo_dir: gems
+- name: csv
+  version: '3.3'
+  source:
+    type: git
+    name: ruby/gem_rbs_collection
+    revision: 9ab762c8247028f90620fc93c4e7aac20eb693d7
+    remote: https://github.com/ruby/gem_rbs_collection.git
+    repo_dir: gems
+- name: date
+  version: '0'
+  source:
+    type: stdlib
+- name: digest
+  version: '0'
+  source:
+    type: stdlib
+- name: erb
+  version: '0'
+  source:
+    type: stdlib
+- name: ffi
+  version: 1.17.4
+  source:
+    type: rubygems
+- name: fileutils
+  version: '0'
+  source:
+    type: stdlib
+- name: forwardable
+  version: '0'
+  source:
+    type: stdlib
+- name: i18n
+  version: '1.10'
+  source:
+    type: git
+    name: ruby/gem_rbs_collection
+    revision: 9ab762c8247028f90620fc93c4e7aac20eb693d7
+    remote: https://github.com/ruby/gem_rbs_collection.git
+    repo_dir: gems
+- name: io-console
+  version: '0'
+  source:
+    type: stdlib
+- name: json
+  version: '0'
+  source:
+    type: stdlib
+- name: listen
+  version: '3.9'
+  source:
+    type: git
+    name: ruby/gem_rbs_collection
+    revision: 9ab762c8247028f90620fc93c4e7aac20eb693d7
+    remote: https://github.com/ruby/gem_rbs_collection.git
+    repo_dir: gems
+- name: logger
+  version: '1.7'
+  source:
+    type: git
+    name: ruby/gem_rbs_collection
+    revision: 9ab762c8247028f90620fc93c4e7aac20eb693d7
+    remote: https://github.com/ruby/gem_rbs_collection.git
+    repo_dir: gems
+- name: minitest
+  version: '5.25'
+  source:
+    type: git
+    name: ruby/gem_rbs_collection
+    revision: 9ab762c8247028f90620fc93c4e7aac20eb693d7
+    remote: https://github.com/ruby/gem_rbs_collection.git
+    repo_dir: gems
+- name: monitor
+  version: '0'
+  source:
+    type: stdlib
+- name: openssl
+  version: '0'
+  source:
+    type: stdlib
+- name: optparse
+  version: '0'
+  source:
+    type: stdlib
+- name: parser
+  version: '3.2'
+  source:
+    type: git
+    name: ruby/gem_rbs_collection
+    revision: 9ab762c8247028f90620fc93c4e7aac20eb693d7
+    remote: https://github.com/ruby/gem_rbs_collection.git
+    repo_dir: gems
+- name: pp
+  version: '0'
+  source:
+    type: stdlib
+- name: prettyprint
+  version: '0'
+  source:
+    type: stdlib
+- name: prism
+  version: 1.9.0
+  source:
+    type: rubygems
+- name: rainbow
+  version: '3.0'
+  source:
+    type: git
+    name: ruby/gem_rbs_collection
+    revision: 9ab762c8247028f90620fc93c4e7aac20eb693d7
+    remote: https://github.com/ruby/gem_rbs_collection.git
+    repo_dir: gems
+- name: rake
+  version: '13.0'
+  source:
+    type: git
+    name: ruby/gem_rbs_collection
+    revision: 9ab762c8247028f90620fc93c4e7aac20eb693d7
+    remote: https://github.com/ruby/gem_rbs_collection.git
+    repo_dir: gems
+- name: random-formatter
+  version: '0'
+  source:
+    type: stdlib
+- name: rbs
+  version: 4.0.0
+  source:
+    type: rubygems
+- name: rdoc
+  version: '0'
+  source:
+    type: stdlib
+- name: securerandom
+  version: '0'
+  source:
+    type: stdlib
+- name: singleton
+  version: '0'
+  source:
+    type: stdlib
+- name: socket
+  version: '0'
+  source:
+    type: stdlib
+- name: steep
+  version: 2.0.0.dev
+  source:
+    type: rubygems
+- name: stringio
+  version: '0'
+  source:
+    type: stdlib
+- name: strscan
+  version: '0'
+  source:
+    type: stdlib
+- name: time
+  version: '0'
+  source:
+    type: stdlib
+- name: timeout
+  version: '0'
+  source:
+    type: stdlib
+- name: tsort
+  version: '0'
+  source:
+    type: stdlib
+- name: tzinfo
+  version: '2.0'
+  source:
+    type: git
+    name: ruby/gem_rbs_collection
+    revision: 9ab762c8247028f90620fc93c4e7aac20eb693d7
+    remote: https://github.com/ruby/gem_rbs_collection.git
+    repo_dir: gems
+- name: uri
+  version: '0'
+  source:
+    type: stdlib
+gemfile_lock_path: Gemfile.lock

data/rbs_collection.yaml

@@ -0,0 +1,25 @@
+# Download sources
+sources:
+  - type: git
+    name: ruby/gem_rbs_collection
+    remote: https://github.com/ruby/gem_rbs_collection.git
+    revision: main
+    repo_dir: gems
+
+# You can specify local directories as sources also.
+# - type: local
+#   path: path/to/your/local/repository
+
+# A directory to install the downloaded RBSs
+path: .gem_rbs_collection
+
+gems:
+  - name: typeprof
+    ignore: true
+  # steep's own dependency; under rbs 4.0 its gem-bundled sig/ directory is
+  # loaded once by the collection and once by steep itself, and the double
+  # insert raises RBS::DuplicatedDeclarationError — which kills steep's load
+  # thread and leaves `steep check` waiting forever. Nothing in lib/ touches
+  # the LSP types, so drop the collection-side copy.
+  - name: language_server-protocol
+    ignore: true

data/sig/ryac/analysis/constant/collection.rbs

@@ -0,0 +1,30 @@
+module Ryac
+  module AnalysisPhases
+    def each_constant_event: (Prism::Node prism_root) { (Symbol, Prism::Node, Array[Symbol]?, bool, bool) -> void } -> void
+    def class_definition_cpath: (Prism::ClassNode | Prism::ModuleNode node, Array[Symbol] nesting) -> Array[Symbol]?
+    def qualified_write_cpath: (Prism::Node target, Array[Symbol] nesting, ?strip_doubled_nesting: bool) -> Array[Symbol]?
+    def syntactic_const_segments: (Prism::Node node) -> Array[Symbol]
+    def struct_definition_write?: (Prism::Node node) -> bool
+    def collect_constants: (Prism::Node prism_root) -> void
+    def exclude_private_constants: (Prism::Node prism_root) -> void
+    def count_constant_references: (Prism::Node prism_root) -> void
+    def increment_constant_read_usage: (Prism::Node node) -> void
+    def resolve_user_defined_cpath: (Prism::Node node) -> Array[Symbol]?
+    def resolve_superclass_path: (Prism::Node superclass_node, Array[Symbol] class_cpath) -> Array[Symbol]?
+    def augment_constant_counts_via_oracle: () -> void
+    def collect_external_references: (Prism::Node prism_root) -> void
+    def precompute_constant_resolution: () -> void
+    def record_constant_read: (Prism::Node node) -> void
+    def mark_chain_prefixes: (Prism::Node node, Set[Integer] counted_prefix_ids) -> void
+    def external_prefix_for: (Prism::Node node) -> Array[Symbol]?
+    def complete_const_chain?: (Prism::Node node) -> bool
+    def required_external_root?: (Symbol root) -> bool
+  end
+
+  module BootConstants
+    self.@cache: Hash[Array[String], Set[Symbol]?]
+
+    def self.for: (Array[String] stdlib_requires) -> Set[Symbol]?
+    def self.probe: (Array[String] stdlib_requires) -> Set[Symbol]?
+  end
+end

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

@@ -0,0 +1,60 @@
+module Ryac
+  class ExternalPrefixInfo
+    attr_accessor prefix_path: Array[Symbol]
+    attr_accessor prefix_string: String?
+    attr_accessor short_name: String?
+    attr_accessor usage_count: Integer
+    attr_accessor char_savings: Integer
+
+    def self.new: (?prefix_path: Array[Symbol]?, ?prefix_string: String?, ?short_name: String?, ?usage_count: Integer?, ?char_savings: Integer?) -> ExternalPrefixInfo
+    def initialize: (?prefix_path: Array[Symbol]?, ?prefix_string: String?, ?short_name: String?, ?usage_count: Integer?, ?char_savings: Integer?) -> void
+  end
+
+  class ConstantInfo
+    attr_accessor original_name: Symbol?
+    attr_accessor full_path: Array[Symbol]
+    attr_accessor short_name: String?
+    attr_accessor usage_count: Integer
+    attr_accessor definition_type: Symbol?
+    attr_accessor scope_path: Array[Symbol]
+
+    def self.new: (?original_name: Symbol?, ?full_path: Array[Symbol]?, ?short_name: String?, ?usage_count: Integer?, ?definition_type: Symbol?, ?scope_path: Array[Symbol]?) -> ConstantInfo
+    def initialize: (?original_name: Symbol?, ?full_path: Array[Symbol]?, ?short_name: String?, ?usage_count: Integer?, ?definition_type: Symbol?, ?scope_path: Array[Symbol]?) -> void
+  end
+
+  class ConstantRenameMapping
+    attr_reader mappings: Hash[Array[Symbol], ConstantInfo]
+    attr_reader used_short_names: Set[String]
+
+    @state: Symbol
+    @by_name: Hash[Symbol, Array[ConstantInfo]]
+    @external_prefixes: Hash[Array[Symbol], ExternalPrefixInfo]
+
+    def initialize: (?boot_roots: Set[Symbol]?) -> void
+    def empty?: () -> bool
+    def finalized?: () -> bool
+    def add_definition_with_path: (Array[Symbol] static_cpath, definition_type: Symbol) -> void
+    def increment_usage_by_path: (Array[Symbol] static_cpath) -> void
+    def increment_usage: (Symbol name) -> void
+    def exclude_path: (Array[Symbol] static_cpath) -> void
+    def assign_short_names: (NameGenerator name_generator, ?skip_class_modules: bool) -> void
+    def generate_alias_declarations: () -> Array[String]
+    def short_name_for_path: (Array[Symbol]? static_cpath) -> String?
+    def short_name_for: (Symbol name) -> String?
+    def user_defined_path?: (Array[Symbol]? static_cpath) -> bool
+    def usage_count_for_path: (Array[Symbol] static_cpath) -> Integer
+    def set_usage_count_by_path: (Array[Symbol] static_cpath, Integer count) -> void
+    def each_user_defined_path: () { (Array[Symbol]) -> void } -> void
+    def class_or_module_path?: (Array[Symbol]? static_cpath) -> bool
+    def has_user_defined_prefix?: (Array[Symbol] full_path) -> bool
+    def add_external_prefix: (Array[Symbol] prefix_path, usage_count: Integer) -> void
+    def short_name_for_prefix: (Array[Symbol]? full_path) -> String?
+    def generate_prefix_declarations: () -> Array[String]
+
+    private
+
+    def external_class_root?: (Array[Symbol] cpath) -> bool
+    def runtime_constant?: (Array[Symbol] cpath) -> bool
+    def build_alias_declaration: (ConstantInfo info) -> String?
+  end
+end

data/sig/ryac/analysis/cvar/collection.rbs

@@ -0,0 +1,11 @@
+module Ryac
+  module AnalysisPhases
+    DYNAMIC_CVAR_METHODS: Array[Symbol]
+    CVAR_WRITE_NODES: Array[Class]
+    type cvar_write_node = Prism::ClassVariableWriteNode | Prism::ClassVariableTargetNode | Prism::ClassVariableOperatorWriteNode | Prism::ClassVariableOrWriteNode | Prism::ClassVariableAndWriteNode
+
+    def collect_cvar_definitions: (Prism::Node prism_root) -> void
+    def scan_dynamic_cvar_access: (Prism::Node prism_root) -> void
+    def merge_inherited_cvars: () -> void
+  end
+end

data/sig/ryac/analysis/gvar/collection.rbs

@@ -0,0 +1,9 @@
+module Ryac
+  module AnalysisPhases
+    GVAR_NODES: Array[Class]
+    type gvar_node = Prism::GlobalVariableReadNode | Prism::GlobalVariableWriteNode | Prism::GlobalVariableTargetNode | Prism::GlobalVariableOperatorWriteNode | Prism::GlobalVariableOrWriteNode | Prism::GlobalVariableAndWriteNode
+
+    def collect_gvar_definitions: (Prism::Node prism_root) -> void
+    def scan_alias_globals: (Prism::Node prism_root) -> void
+  end
+end

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

@@ -0,0 +1,23 @@
+module Ryac
+  class GvarRenameMapping
+    PREFIX: String
+    KEPT_NAME_MAX: Integer
+    PERL_SPELLINGS: Hash[Symbol, String]
+    BUILT_IN_GLOBALS: Set[Symbol]
+
+    @gvars: Hash[Symbol, Array[Prism::Node]]
+    @written_names: Set[Symbol]
+    @excluded_names: Set[Symbol]
+    @node_short_names: Hash[[Integer, Integer], String]
+
+    def initialize: () -> void
+
+    def add_site: (Symbol name, Prism::Node node, ?write: bool) -> void
+
+    def exclude_name: (Symbol name) -> void
+
+    def assign_short_names: () -> void
+
+    def node_mapping: () -> Hash[[Integer, Integer], String]
+  end
+end

data/sig/ryac/analysis/ivar/collection.rbs

@@ -0,0 +1,26 @@
+module Ryac
+  module AnalysisPhases
+    DYNAMIC_IVAR_METHODS: Array[Symbol]
+    ATTR_DECLARATION_METHODS: Array[Symbol]
+    IVAR_WRITE_NODES: Array[Class]
+    type ivar_write_node = Prism::InstanceVariableWriteNode | Prism::InstanceVariableTargetNode | Prism::InstanceVariableOperatorWriteNode | Prism::InstanceVariableOrWriteNode | Prism::InstanceVariableAndWriteNode
+
+    def collect_ivar_definitions: (Prism::Node prism_root, Hash[Array[Symbol], Set[Symbol]] attr_backed) -> void
+    def collect_attr_backed_ivars: (Prism::Node prism_root) -> Hash[Array[Symbol], Set[Symbol]]
+    def scan_dynamic_ivar_access: (Prism::Node prism_root) -> void
+    def merge_inherited_ivars: () -> void
+    def scan_dynamic_sigil_access: (Prism::Node prism_root, Array[Symbol] methods, SiteBucketMapping mapping) -> void
+    def merge_inherited_sites: (SiteBucketMapping mapping) -> void
+    def reserve_attr_ivar_names: (Prism::Node prism_root) -> void
+    def coordinate_attr_renames: (Prism::Node prism_root, Hash[location_key, String] rename_map, Hash[location_key, String] attr_ivar_entries) -> Hash[location_key, Hash[Symbol, String]]
+
+    type attr_info = Hash[Symbol, untyped]
+
+    def classify_attr_declarations: (Prism::Node prism_root) -> [Array[attr_info], Array[attr_info]]
+    def collect_ivar_nodes_by_key: (Prism::Node prism_root) -> Hash[[Array[Symbol], Symbol], Array[Prism::Node]]
+    def assign_ivar_driven_names: (Array[attr_info] path_b_info, Hash[[Array[Symbol], Symbol], Array[Prism::Node]] ivar_nodes_by_key, Hash[[Array[Symbol], Symbol], String] path_a_mapping, Hash[location_key, String] rename_map) -> [Hash[[Array[Symbol], Symbol], String], Hash[[Array[Symbol], Symbol], Symbol]]
+    def apply_ivar_renames: (Hash[[Array[Symbol], Symbol], Array[Prism::Node]] ivar_nodes_by_key, Hash[[Array[Symbol], Symbol], String] combined_mapping, Hash[location_key, String] attr_ivar_entries) -> void
+    def apply_accessor_call_renames: (Array[attr_info] path_a_info, Array[attr_info] path_b_info, Hash[[Array[Symbol], Symbol], Symbol] path_b_method_mapping, Hash[location_key, String] rename_map) -> void
+    def build_attr_rename_map: (Array[attr_info] path_a_info, Array[attr_info] path_b_info, Hash[[Array[Symbol], Symbol], Symbol] path_b_method_mapping) -> Hash[location_key, Hash[Symbol, String]]
+  end
+end

data/sig/ryac/analysis/keyword/collection.rbs

@@ -0,0 +1,27 @@
+module Ryac
+  module AnalysisPhases
+    def collect_keyword_info: (Prism::Node prism_root) -> void
+
+    private
+
+    def each_attr_declaration: (Prism::Node prism_root, Array[Symbol] methods, ?require_class_body: bool) { (Prism::CallNode, Array[Symbol], bool, Symbol) -> void } -> void
+    def def_keyword_names: (Prism::DefNode def_node) -> Array[Symbol]
+    def def_keyword_rest?: (Prism::DefNode def_node) -> bool
+    def collect_keyword_call_sites: (Prism::Node prism_root) -> void
+    def forwards_parameters_to_super?: (Prism::DefNode def_node) -> bool
+    def register_keyword_calls: () -> Hash[Symbol, untyped]
+    def merge_super_forwarding: (Array[[method_key, method_key]] super_merges) -> void
+    def merge_polymorphic_keyword_groups: (Hash[location_key, Array[method_key]] call_node_to_keys) -> void
+    def exclude_unreachable_keyword_methods: (Array[method_key] zero_call_keys, Array[[method_key, method_key]] super_merges) -> void
+    def exclude_unresolved_keyword_calls: (Prism::Node prism_root, Set[location_key] resolved_site_keys) -> void
+    def carries_keyword_arguments?: (Prism::CallNode call_node) -> bool
+
+    public
+      @keyword_def_node_registry: Hash[method_key, Array[Prism::DefNode]]
+      @keyword_forwarding_super_keys: Set[method_key]
+
+      private
+
+      def exclude_method_valued_shorthand_calls: (Prism::Node prism_root) -> void
+  end
+end

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

@@ -0,0 +1,31 @@
+module Ryac
+  class KeywordRenameMapping
+    include UnionFind[method_key]
+
+    type call_entry = { symbol_node: Prism::SymbolNode, val_node: Prism::Node }
+    type keyword_method_info = { keywords: Set[Symbol], call_entries: Hash[Symbol, Array[call_entry]], excluded: bool }
+
+    @methods: Hash[method_key, keyword_method_info]
+    @node_short_names: Hash[location_key, String]
+    # Keyed by each group's union-find root.
+    @keyword_maps: Hash[method_key, Hash[Symbol, String]]
+    @frozen: bool
+
+    def initialize: () -> void
+    def add_keyword_def: (method_key method_key, Symbol keyword_sym) -> void
+    def add_keyword_call: (method_key method_key, Symbol keyword_sym, Prism::SymbolNode symbol_node, Prism::Node val_node) -> void
+    def exclude_method: (method_key method_key) -> void
+
+    def exclude_methods_by_mid: (Enumerable[Symbol] mids) -> void
+    def merge_groups: (method_key key1, method_key key2) -> void
+    def each_method_key: () { (method_key) -> void } -> void
+    def assign_short_names: () -> void
+    def node_mapping: () -> Hash[location_key, String]
+    def def_node_mapping: (Hash[method_key, Array[Prism::DefNode]] def_node_registry) -> Hash[location_key, Hash[Symbol, String]]
+    def build_variable_hints: () { (Prism::Node) -> scope_id? } -> Hash[scope_id, Hash[Symbol, String]]
+
+    private
+
+    def init_method: (method_key method_key) -> void
+  end
+end

data/sig/ryac/analysis/local_scopes.rbs

@@ -0,0 +1,77 @@
+module Ryac
+  class LocalScopes
+    include RenameInvariants
+
+    DYNAMIC_VARIABLE_METHODS: Array[Symbol]
+    NUMBERED_PARAM_RE: Regexp
+    VARIABLE_NODES: Array[Class]
+
+    type prism_scope_node = Prism::ProgramNode | Prism::DefNode | Prism::ClassNode
+                          | Prism::ModuleNode | Prism::SingletonClassNode
+                          | Prism::BlockNode | Prism::LambdaNode
+    type prism_variable_node = Prism::LocalVariableReadNode | Prism::LocalVariableWriteNode
+                             | Prism::LocalVariableTargetNode | Prism::LocalVariableOperatorWriteNode
+                             | Prism::LocalVariableOrWriteNode | Prism::LocalVariableAndWriteNode
+
+    # Runtime class is built via Struct.new(..., keyword_init: true).
+    class Scope
+      def self.new: (?id: scope_id, ?kind: Symbol, ?node: prism_scope_node, ?parent: Scope?, ?owner_call: Prism::CallNode?, ?mapping: Hash[Symbol, String]?) -> Scope
+
+      attr_accessor id: scope_id
+      attr_accessor kind: Symbol
+      attr_accessor node: prism_scope_node
+      attr_accessor parent: Scope?
+      attr_accessor owner_call: Prism::CallNode?
+      attr_accessor mapping: Hash[Symbol, String]?
+
+      def allocated?: () -> bool
+    end
+
+    @program: Prism::ProgramNode
+    @scope_by_node: Hash[Integer, Scope]
+
+    attr_reader scopes: Array[Scope]
+    attr_reader rename_entries: Hash[location_key, String]
+    attr_reader def_param_names: Hash[line_col_key, Hash[Symbol, String]]
+    attr_reader block_param_names: Hash[location_key, Hash[Symbol, String]]
+    attr_reader for_index_names: Hash[line_col_key, String]
+
+    def initialize: (Prism::ProgramNode program_node) -> void
+    def scope_id_at: (Integer offset) -> scope_id?
+    def scope_id_of: (Prism::Node node) -> scope_id?
+    def allocate: (?kw_def_map: Hash[location_key, Hash[Symbol, String]], ?var_hints: Hash[scope_id, Hash[Symbol, String]]) -> self
+    def scope_mappings: () -> scope_mapping_table
+    def resolve: () -> self
+
+    private
+
+    def scope_range: (Scope scope) -> Range[Integer]
+    def add_scope: (Symbol kind, prism_scope_node node, Scope? parent, ?owner_call: Prism::CallNode?) -> Scope
+    def build: (Prism::Node? node, ?Scope? current, ?owner_call: Prism::CallNode?) -> void
+    def allocate_top: (Scope scope) -> void
+    def allocate_def: (Scope scope, Hash[location_key, Hash[Symbol, String]] kw_def_map, Hash[scope_id, Hash[Symbol, String]] var_hints) -> void
+    def allocate_block: (Scope scope) -> void
+    def ancestor_mapping_values: (Scope scope) -> Array[String]
+    def scope_constraints: (Prism::Node? body) -> [bool, Set[Symbol]]
+
+    def allocated_name: (Symbol var, bool unsafe, Set[Symbol] pinned, NameGenerator generator) -> String
+    def unused_rescue_vars: (Prism::Node? body) -> Set[Symbol]
+    def keyword_param_names: (Prism::DefNode def_node) -> Array[Symbol]
+    def block_parameters: (Prism::BlockNode block_node) -> Prism::ParametersNode?
+    def block_formal_names: (Prism::BlockNode block_node) -> Array[Symbol?]
+    def block_multi_targets: (Prism::BlockNode block_node) -> Array[Prism::MultiTargetNode]
+    def use_numbered_params?: (Prism::BlockNode block_node, Array[Symbol?] f_args, Array[String] parent_names) -> bool
+    def collect_multi_target_names: (Prism::MultiTargetNode multi_target_node) -> Array[Symbol]
+    def collect_extra_block_param_names: (Prism::ParametersNode prism_params) -> Array[Symbol]
+    def block_has_non_required_params?: (Prism::ParametersNode? params) -> boolish
+    def walk_all: (Prism::Node? node) { (Prism::Node) -> void } -> void
+    def resolve_walk: (Prism::Node? node, Array[Scope] stack) -> void
+    def enter_scope: (Scope scope, Array[Scope] stack) -> void
+    def record_variable: (prism_variable_node node, Array[Scope] stack) -> void
+    def resolved_name: (Symbol name, Integer depth, Array[Scope] stack) -> String
+    def record_def_params: (Prism::DefNode def_node, Scope scope) -> void
+    def each_def_param_name: (Prism::ParametersNode params) { (Symbol) -> void } -> void
+    def record_block_params: (Prism::BlockNode block_node, Scope scope) -> void
+    def record_for_index: (Prism::ForNode for_node, Array[Scope] stack) -> void
+  end
+end

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

@@ -0,0 +1,25 @@
+module Ryac
+  module AnalysisPhases
+    def collect_method_definitions: (Prism::Node prism_root) -> void
+    def resolve_method_calls: () -> void
+    def scan_dynamic_method_references: (Prism::Node prism_root) -> void
+    def collect_visibility_modifier_methods: (Prism::Node prism_root) -> void
+    def collect_alias_undef_methods: (Prism::Node prism_root) -> void
+
+    DYNAMIC_DISPATCH_METHODS: Array[Symbol]
+    VISIBILITY_MODIFIERS: Array[Symbol]
+    UNRESOLVED_CALL_NODES: Array[Class]
+
+    private
+
+    def link_module_function_variant: (Prism::DefNode def_node, method_key method_key) -> void
+    def merge_super_groups: (Array[[method_key, method_key]] super_merges) -> void
+    def merge_polymorphic_groups: (Hash[location_key, Array[method_key]] call_node_to_keys) -> void
+    def merge_unresolved_calls: (Set[location_key] resolved_call_keys) -> void
+    def classify_unresolved_call: (Symbol mid, Prism::Node node) -> Symbol
+
+    public
+      def collect_shorthand_pun_methods: (Prism::Node prism_root) -> void
+      def collect_attr_write_exclusions: (Prism::Node prism_root) -> void
+  end
+end