ryac 0.2.0 → 0.3.0

data/lib/ryac/pipeline/analyzer.rb

@@ -42,9 +42,19 @@ module Ryac
         )
       end
 
+      def initialize(method_policy: :aggressive)
+        @method_policy = method_policy
+      end
+
       def call(source)
         prism_result, @oracle = without_stdout_pollution { setup_typeprof(source) }
         @prism_root = prism_result.value
+        @lazy_regions = LazyRegions.collect(@prism_root)
+        # A program that loads files dynamically had enumerated its external
+        # readers; bundled as lazy regions, they are all inside now, and what
+        # is left outside is a launcher — which spells the class/module
+        # skeleton, never a value constant.
+        @alias_surface = source.lazy_files.empty? ? :full : :skeleton
         @boot_constant_roots = BootConstants.for(source.stdlib_requires)
         @syntax_data = collect_syntax_data(@prism_root)
 
@@ -99,7 +109,7 @@ module Ryac
           raise InvalidOutputError.new('pre-rename source', prism_result.errors)
         end
 
-        [prism_result, TypeOracle.boot(source.content, source.rbs_files)]
+        [prism_result, TypeOracle.boot(source.content, source.rbs_files, prism_result.value)]
       end
 
       def analyze_keywords_and_scopes
@@ -120,18 +130,25 @@ module Ryac
         )
         @local_scopes.resolve
         @scope_mappings = @local_scopes.scope_mappings
+        @scope_visible_names = @local_scopes.visible_local_names
       end
 
       def analyze_methods_phase
         @method_rename_mapping = MethodRenameMapping.new
         collect_method_definitions(@prism_root)
+        collect_dynamic_ivar_attr_exclusions(@prism_root)
+        collect_inherited_attr_exclusions(@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)
+        if @method_policy == :safe
+          collect_string_literal_mentions(@prism_root)
+          @method_rename_mapping.exclude_uncalled_methods
+        end
+        @method_rename_mapping.assign_short_names(@scope_visible_names, @oracle)
       end
 
       def analyze_variables_phase
@@ -156,9 +173,14 @@ module Ryac
       end
 
       def analyze_constants_phase
-        @constant_mapping = ConstantRenameMapping.new(boot_roots: @boot_constant_roots)
+        @constant_mapping = ConstantRenameMapping.new(
+          boot_roots: @boot_constant_roots,
+          alias_surface: @alias_surface
+        )
         collect_constants(@prism_root)
         exclude_private_constants(@prism_root)
+        exclude_lazy_definitions(@prism_root)
+        exclude_dynamic_root_reads(@prism_root)
         count_constant_references(@prism_root)
         augment_constant_counts_via_oracle
         collect_external_references(@prism_root)

data/lib/ryac/pipeline/concatenator.rb

@@ -7,6 +7,12 @@ module Ryac
     # Stage 2: File Concatenation
     # Performs topological sort and concatenates files in dependency order
     class Concatenator
+      # The registry lazy regions register into and the loader that runs
+      # them: ordinary source, minified with everything else (both get short
+      # names), spelled so as not to collide with the program's own names.
+      REGISTRY_NAME = 'RYAC_LAZY'
+      LOADER_NAME = 'ryac_require'
+
       # @param graph [DependencyGraph] From Stage 1
       # @return [ConcatenatedSource] Ordered, concatenated source
       # @raise [CircularDependencyError] If cycle detected in graph
@@ -102,21 +108,35 @@ module Ryac
         inlined = Set.new
         current_line = 1
 
+        lazy_paths = graph.lazy_paths
+        @root = common_root(graph.paths)
+        @registry, @loader = lazy_paths.empty? ? [nil, nil] : bundle_names(graph)
+
         # Pre-clean all files: resolve in-class requires by inlining
         cleaned_cache = {} #: Hash[String, String]
         sorted_paths.each do |path|
           entry = graph[path]
           next unless entry
-          collect_stdlib_requires(entry, stdlib_requires)
+          collect_stdlib_requires(entry, stdlib_requires) unless entry.lazy
           cleaned_cache[path] = process_require_statements(entry, graph, inlined, cleaned_cache)
         end
 
-        sorted_paths.each do |path|
+        if (registry = @registry) && (loader = @loader)
+          prelude = loader_prelude(registry, loader)
+          content_parts << prelude
+          current_line += prelude.count("\n") + 1
+        end
+
+        # Regions first: registering is all a region does at load, and it
+        # has to be registered before any code that could ask for it runs.
+        lazy, flat = sorted_paths.partition { |path| graph[path]&.lazy }
+        (lazy + flat).each do |path|
           next if inlined.include?(path)
           entry = graph[path]
           next unless entry
 
           cleaned_content = cleaned_cache[path]
+          cleaned_content = lazy_registration(path, cleaned_content) if entry.lazy
           lines = cleaned_content.count("\n") + 1
 
           file_boundaries << FileBoundary.new(
@@ -136,10 +156,76 @@ module Ryac
           file_boundaries: file_boundaries,
           original_size: original_size,
           stdlib_requires: stdlib_requires.uniq,
-          rbs_files: graph.rbs_files
+          rbs_files: graph.rbs_files,
+          lazy_files: lazy_paths
         )
       end
 
+      # The directory every bundled file sits under. Region keys and the
+      # respelled prefix of a dynamic require site are both relative to it,
+      # which is what makes a key and the string the site builds at runtime
+      # agree.
+      def common_root(paths)
+        root = File.dirname(paths.fetch(0))
+        root = File.dirname(root) until root == '/' || paths.all? { |p| p.start_with?("#{root}/") }
+        root
+      end
+
+      def relative_to_root(path)
+        path.delete_prefix(@root == '/' ? '/' : "#{@root}/")
+      end
+
+      def lazy_key(path)
+        relative_to_root(path).delete_suffix('.rb')
+      end
+
+      # Names the program does not spell anywhere.
+      def bundle_names(graph)
+        contents = graph.files.each_value.map(&:content)
+        [REGISTRY_NAME, LOADER_NAME].map { |base| unused_name(base, contents) }
+      end
+
+      def unused_name(base, contents)
+        name = base
+        suffix = 0
+        while contents.any? { |c| c.match?(/\b#{Regexp.escape(name)}\b/) }
+          suffix += 1
+          name = "#{base}_#{suffix}"
+        end
+        name
+      end
+
+      # The loader keeps Ruby's require contract for the regions it owns: a
+      # region runs once and answers true, a repeat answers false, a region
+      # whose run raised (its `require "ffi"` had no ffi) is restored so a
+      # later require can try it again, and a path no region was registered
+      # under falls through to a real require_relative — relative to the
+      # bundle, the one file all this code now lives in.
+      def loader_prelude(registry, loader)
+        <<~RUBY
+          #{registry} = {}
+          def #{loader}(path)
+            return require_relative(path) unless #{registry}.key?(path)
+            body = #{registry}[path]
+            return false unless body
+            #{registry}[path] = false
+            begin
+              body.call
+            rescue Exception
+              #{registry}[path] = body
+              raise
+            end
+            true
+          end
+        RUBY
+      end
+
+      # The file as a region (see LazyRegions): its own line for the closing
+      # brace, so a trailing comment cannot swallow it.
+      def lazy_registration(path, content)
+        "#{@registry}[#{lazy_key(path).dump}] = -> {\n#{content}\n}"
+      end
+
       # Hoisting a require to the top of the output makes it run at load time.
       # That is fine for one the file already ran at load time, but a require
       # inside a method body runs only when the method is called and is often
@@ -163,13 +249,13 @@ module Ryac
         nodes_with_offsets = require_nodes.select { |n| n[:start_offset] }
 
         if nodes_with_offsets.size == require_nodes.size
-          offset_based_processing(content, nodes_with_offsets, graph, in_class_deps, inlined, cleaned_cache)
+          offset_based_processing(content, nodes_with_offsets, graph, in_class_deps, inlined, cleaned_cache, entry.lazy)
         else
           line_based_processing(content, require_nodes)
         end
       end
 
-      def offset_based_processing(content, nodes, graph, in_class_deps, inlined, cleaned_cache)
+      def offset_based_processing(content, nodes, graph, in_class_deps, inlined, cleaned_cache, lazy_entry)
         sorted_nodes = nodes.sort_by { |n| n[:start_offset] }.reverse
         # Prism offsets are byte offsets: splice on bytes, or any multibyte
         # character before a require shifts every slice after it.
@@ -178,8 +264,22 @@ module Ryac
           start_pos = node[:start_offset]
           end_pos = start_pos + node[:length]
 
+          if node[:type] == :require_lazy
+            result[start_pos...end_pos] = lazy_site_call(result, node).b
+            next
+          end
+
+          dep_path = resolve_node_path(node, graph)
+          # A require that names a region asks the loader for it, whether
+          # the site is a static sibling require inside another region or
+          # an autoload — which then loads at that point, as it does for a
+          # flat file.
+          if dep_path && graph[dep_path]&.lazy
+            result[start_pos...end_pos] = "#{@loader}(#{lazy_key(dep_path).dump})".b
+            next
+          end
+
           if node[:in_class] && !node[:in_method] && node[:type] != :require_stdlib
-            dep_path = resolve_node_path(node, graph)
             if dep_path && graph[dep_path]
               # the `graph[dep_path]` check above guarantees the entry exists
               dep_content = cleaned_cache[dep_path] || graph[dep_path].content # steep:ignore NoMethod
@@ -195,8 +295,9 @@ module Ryac
           end
 
           # An in-method stdlib require is not hoisted, so it has to stay where
-          # it is — deleting it here would drop the require altogether.
-          next if node[:type] == :require_stdlib && node[:in_method]
+          # it is — deleting it here would drop the require altogether. Nothing
+          # in a region is hoisted: its requires run when the region does.
+          next if node[:type] == :require_stdlib && (node[:in_method] || lazy_entry)
 
           # For removal: consume trailing semicolons and newlines
           while end_pos < result.size && (result[end_pos] == ';' || result[end_pos] == "\n")
@@ -207,6 +308,24 @@ module Ryac
         result.force_encoding(content.encoding)
       end
 
+      # `require_relative "driver/#{name}_#{type}"` becomes
+      # `ryac_require("optcarrot/driver/#{name}_#{type}")`: the literal keeps
+      # its interpolation, its static prefix is respelled relative to the
+      # bundle root — the spelling the regions were registered under — and a
+      # literal ".rb" tail goes, as keys carry no extension. The bytes are
+      # read before this node's own edit, so every offset is still original.
+      def lazy_site_call(bytes, node)
+        site = node.fetch(:lazy)
+        arg = bytes[site[:arg_start_offset]...site[:arg_end_offset]] #: String
+        base = site[:arg_start_offset]
+        if (suffix_start = site[:suffix_start_offset])
+          arg[(suffix_start - base), 3] = ''
+        end
+        dir = site[:dir]
+        arg[(site[:prefix_start_offset] - base), site[:prefix_length]] = (dir == @root ? '' : "#{relative_to_root(dir)}/").b
+        "#{@loader}(#{arg})"
+      end
+
       def line_based_processing(content, require_nodes)
         lines = content.lines
         lines_to_remove = Set.new

data/lib/ryac/pipeline/data_types.rb

@@ -9,10 +9,11 @@ module Ryac
       :content,               # String: Raw file content
       :dependencies,          # Array<String>: Absolute paths of required files (top-level requires only)
       :require_nodes,         # Array<Hash>: {type:, path:, line:, in_class:} for require/autoload nodes
-      :in_class_dependencies  # Array<String>: Absolute paths of files required inside class/module bodies
+      :in_class_dependencies, # Array<String>: Absolute paths of files required inside class/module bodies
+      :lazy                   # Boolean: reached only through a dynamic require — bundled as a lazy region, run on demand
     ) do
       # declared on the Data class itself in the RBS
-      def initialize(path:, content:, dependencies:, require_nodes:, in_class_dependencies: []) # steep:ignore UndeclaredMethodDefinition
+      def initialize(path:, content:, dependencies:, require_nodes:, in_class_dependencies: [], lazy: false) # steep:ignore UndeclaredMethodDefinition
         super
       end
     end
@@ -29,6 +30,11 @@ module Ryac
         @rbs_files = {}   # Hash<String, String>: path -> RBS content
       end
 
+      # The files bundled as lazy regions, in path order.
+      def lazy_paths
+        @files.each_value.select(&:lazy).map(&:path).sort
+      end
+
       # Add a file entry to the graph
       # @param entry [FileEntry] The file entry to add
       def add_file(entry)
@@ -87,15 +93,17 @@ module Ryac
       :file_boundaries,  # Array<FileBoundary>: Line ranges are true at concatenation only; the pipeline rewrites the text from compaction on
       :original_size,    # Integer: Bytes of the input the content descends from
       :stdlib_requires,  # Array<String>: Standard library requires to preserve
-      :rbs_files         # Hash<String, String>: path -> RBS content for TypeProf
+      :rbs_files,        # Hash<String, String>: path -> RBS content for TypeProf
+      :lazy_files        # Array<String>: paths of the files bundled as lazy regions (see LazyRegions)
     ) do
       # A source built straight from a string (tests, sub-pipelines) has no
       # file ancestry: everything but the content defaults away, and its
       # original size is the content itself.
-      def initialize(content:, file_boundaries: [], original_size: nil, stdlib_requires: [], rbs_files: {}) # steep:ignore UndeclaredMethodDefinition
+      def initialize(content:, file_boundaries: [], original_size: nil, stdlib_requires: [], rbs_files: {}, lazy_files: []) # steep:ignore UndeclaredMethodDefinition
         super(content: content, file_boundaries: file_boundaries,
               original_size: original_size || content.bytesize,
-              stdlib_requires: stdlib_requires, rbs_files: rbs_files)
+              stdlib_requires: stdlib_requires, rbs_files: rbs_files,
+              lazy_files: lazy_files)
       end
     end
 

data/lib/ryac/pipeline/file_collector.rb

@@ -20,6 +20,7 @@ module Ryac
 
         @graph = DependencyGraph.new
         @visited = Set.new
+        @pending_lazy = [] #: Array[String]
         @gem_names = gem_names
         @project_roots = if project_root
           # Array() leaves only Strings whichever of the two shapes came in
@@ -37,6 +38,11 @@ module Ryac
           collect_file(expanded)
         end
 
+        # Only once the static world is complete: a candidate it reached is
+        # bundled flat and already visited; the rest — and whatever they
+        # require that nothing static did — become lazy regions.
+        collect_file(@pending_lazy.shift, lazy: true) until @pending_lazy.empty?
+
         collect_rbs_files(entry_paths)
         @graph
       end
@@ -44,7 +50,7 @@ module Ryac
       private
 
       # Recursively collect a file and its dependencies
-      def collect_file(file_path, required_from: nil, line: nil)
+      def collect_file(file_path, required_from: nil, line: nil, lazy: false)
         return if @visited.include?(file_path)
 
         unless File.exist?(file_path)
@@ -71,7 +77,7 @@ module Ryac
           else
             dependencies << dep_path
           end
-          collect_file(dep_path, required_from: file_path, line: node_info[:line])
+          collect_file(dep_path, required_from: file_path, line: node_info[:line], lazy: lazy)
         end
 
         entry = FileEntry.new(
@@ -79,7 +85,8 @@ module Ryac
           content: content,
           dependencies: dependencies,
           in_class_dependencies: in_class_dependencies,
-          require_nodes: require_nodes
+          require_nodes: require_nodes,
+          lazy: lazy
         )
 
         @graph.add_file(entry)
@@ -123,6 +130,11 @@ module Ryac
         when Prism::IfNode
           traverse_for_requires(node.statements, nodes, file_path, in_method: in_method, in_class: in_class)
           traverse_for_requires(node.subsequent, nodes, file_path, in_method: in_method, in_class: in_class)
+        when Prism::UnlessNode
+          traverse_for_requires(node.statements, nodes, file_path, in_method: in_method, in_class: in_class)
+          traverse_for_requires(node.else_clause, nodes, file_path, in_method: in_method, in_class: in_class)
+        when Prism::ElseNode
+          traverse_for_requires(node.statements, nodes, file_path, in_method: in_method, in_class: in_class)
         when Prism::BeginNode
           traverse_for_requires(node.statements, nodes, file_path, in_method: in_method, in_class: in_class)
         end
@@ -163,7 +175,10 @@ module Ryac
             resolved_path: resolve_relative_path(arg.unescaped, file_path)
           }
         else
-          return if in_method
+          if in_method
+            collect_lazy_candidates(node, arg, nodes, file_path, in_class: in_class)
+            return
+          end
 
           raise DynamicRequireError.new(
             file_path,
@@ -173,6 +188,51 @@ module Ryac
         end
       end
 
+      # A dynamic require inside a method stays a runtime require. When its
+      # path starts with a static directory ("driver/#{name}"), the files it
+      # can load exist on disk now, so they join the bundle — as lazy
+      # regions, each run at the moment the require would have run — and
+      # the site is recorded for the Concatenator to point at the loader.
+      def collect_lazy_candidates(node, arg, nodes, file_path, in_class:)
+        return unless arg.is_a?(Prism::InterpolatedStringNode)
+
+        head = arg.parts.first
+        return unless head.is_a?(Prism::StringNode)
+
+        slash = head.unescaped.rindex('/')
+        return unless slash
+
+        prefix = head.unescaped[0..slash] #: String
+        # The prefix is respelled in place, which needs the source to spell
+        # it as it reads.
+        return unless head.content.start_with?(prefix)
+
+        dir = File.expand_path(prefix, File.dirname(file_path))
+        candidates = Dir.glob(File.join(dir, '*.rb')).sort
+        return if candidates.empty?
+
+        tail = arg.parts.last
+        suffix_start = tail.is_a?(Prism::StringNode) && tail.content.end_with?('.rb') ? tail.content_loc.end_offset - 3 : nil
+        nodes << {
+          type: :require_lazy,
+          path: prefix,
+          line: node.location.start_line,
+          start_offset: node.location.start_offset,
+          length: node.location.length,
+          in_class: in_class,
+          in_method: true,
+          lazy: {
+            dir: dir,
+            arg_start_offset: arg.location.start_offset,
+            arg_end_offset: arg.location.end_offset,
+            prefix_start_offset: head.content_loc.start_offset,
+            prefix_length: prefix.bytesize,
+            suffix_start_offset: suffix_start
+          }
+        }
+        @pending_lazy.concat(candidates)
+      end
+
       def handle_require(node, nodes, file_path, in_method: false, in_class: false)
         arg = node.arguments&.arguments&.first
         return unless arg

data/lib/ryac/pipeline/method_renamer.rb

@@ -3,9 +3,24 @@
 module Ryac
   module Pipeline
     # Method renaming: renames method definitions and call sites.
+    #
+    # policy: :aggressive (default) renames every group the exclusion
+    # passes leave standing, folding unresolved same-name calls and blind
+    # defs into the groups they probably belong to. :safe renames only
+    # groups whose every caller type inference actually resolved — an
+    # unresolved call excludes its name, an uncalled def keeps its name
+    # (it is either dead or someone outside the program calls it), and a
+    # name that appears inside a string literal keeps its spelling (eval
+    # and send-by-string read strings, not the syntax tree).
     class MethodRenamer < Stage
       include RenamePatcher
 
+      def initialize(policy: :aggressive)
+        @policy = policy
+      end
+
+      def analysis_options = { method_policy: @policy }
+
       def needs_analysis? = true
 
       def collect(ctx, patches)

data/lib/ryac/pipeline/stage.rb

@@ -28,6 +28,10 @@ module Ryac
       # true → the runner re-parses and re-collects until no patches remain.
       def fixpoint? = false
 
+      # Keyword options this stage needs the analysis batch's Analyzer to
+      # honor. The runner merges every batch member's contribution.
+      def analysis_options = {}
+
       def collect(ctx, patches)
         raise NotImplementedError, "#{self.class}#collect must be implemented"
       end

data/lib/ryac/pipeline/stage_runner.rb

@@ -15,9 +15,10 @@ module Ryac
     class StageRunner
       include SourcePatcher
 
-      def initialize(stdlib_requires: [], rbs_files: {})
+      def initialize(stdlib_requires: [], rbs_files: {}, lazy_files: [])
         @stdlib_requires = stdlib_requires
         @rbs_files = rbs_files
+        @lazy_files = lazy_files
       end
 
       def call(code, stage_defs)
@@ -65,9 +66,12 @@ module Ryac
         source = ConcatenatedSource.new(
           content: code,
           stdlib_requires: @stdlib_requires,
-          rbs_files: @rbs_files
+          rbs_files: @rbs_files,
+          lazy_files: @lazy_files
         )
-        analysis = Analyzer.new.call(source)
+        options = {} #: Hash[Symbol, untyped]
+        batch.each { |stage| options.merge!(stage.analysis_options) }
+        analysis = Analyzer.new(**options).call(source)
 
         ctx = StageContext.new(code, analysis.prism_ast, analysis, '', '')
         patches = [] #: Array[patch_entry]

data/lib/ryac/version.rb

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

data/lib/ryac.rb

@@ -12,6 +12,7 @@ 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/lazy_regions"
 require_relative "ryac/analysis/type_oracle"
 require_relative "ryac/analysis/constant/collection"
 require_relative "ryac/analysis/method_aliasing"
@@ -26,4 +27,6 @@ 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/packer"
+require_relative "ryac/driver_file"
 require_relative "ryac/gem_resolver"

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

@@ -5,6 +5,9 @@ module Ryac
     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 exclude_lazy_definitions: (Prism::Node prism_root) -> void
+    def exclude_dynamic_root_reads: (Prism::Node prism_root) -> void
+    def dynamic_root?: (Prism::ConstantPathNode 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

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

@@ -29,8 +29,9 @@ module Ryac
     @state: Symbol
     @by_name: Hash[Symbol, Array[ConstantInfo]]
     @external_prefixes: Hash[Array[Symbol], ExternalPrefixInfo]
+    @alias_surface: Symbol
 
-    def initialize: (?boot_roots: Set[Symbol]?) -> void
+    def initialize: (?boot_roots: Set[Symbol]?, ?alias_surface: Symbol) -> void
     def empty?: () -> bool
     def finalized?: () -> bool
     def add_definition_with_path: (Array[Symbol] static_cpath, definition_type: Symbol) -> void

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

@@ -6,6 +6,7 @@ module Ryac
     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 attr_backed_ivar?: (Hash[Array[Symbol], Set[Symbol]] attr_backed, Array[Symbol] cpath, Symbol name) -> bool
     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

data/sig/ryac/analysis/lazy_regions.rbs

@@ -0,0 +1,10 @@
+module Ryac
+  module LazyRegions
+    def self?.collect: (Prism::ProgramNode prism_root) -> Array[Prism::LambdaNode]
+    def self?.contains?: (Array[Prism::LambdaNode] lambdas, Prism::Node node) -> bool
+    def self?.typeprof_view: (String content, Prism::ProgramNode prism_root) -> String
+    def self?.each_registration: (Prism::ProgramNode prism_root) { (Prism::Node, Prism::LambdaNode) -> void } -> void
+    def self?.registration_lambda: (Prism::Node statement) -> Prism::LambdaNode?
+    def self?.blank: (String bytes, Integer from, Integer to) -> void
+  end
+end

data/sig/ryac/analysis/local_scopes.rbs

@@ -29,6 +29,8 @@ module Ryac
 
     @program: Prism::ProgramNode
     @scope_by_node: Hash[Integer, Scope]
+    @children: Hash[Integer, Array[Scope]]
+    @constraints: Hash[scope_id, [bool, Set[Symbol]]]
 
     attr_reader scopes: Array[Scope]
     attr_reader rename_entries: Hash[location_key, String]
@@ -41,6 +43,7 @@ module Ryac
     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 visible_local_names: () -> Hash[scope_id, Set[String]]
     def resolve: () -> self
 
     private
@@ -51,7 +54,12 @@ module Ryac
     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 reserved_names: (Scope scope) -> Array[String]
+    def ancestor_visible_names: (Scope scope) -> Array[String]
+    def descendant_kept_names: (Scope scope) -> Array[String]
+    def kept_local_names: (Scope scope) -> Array[String]
+    def renamed_block_param_names: (Prism::BlockNode node) -> Set[Symbol]
+    def constraints_for: (Scope scope) -> [bool, Set[Symbol]]
     def scope_constraints: (Prism::Node? body) -> [bool, Set[Symbol]]
 
     def allocated_name: (Symbol var, bool unsafe, Set[Symbol] pinned, NameGenerator generator) -> String

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

@@ -1,6 +1,9 @@
 module Ryac
   module AnalysisPhases
     def collect_method_definitions: (Prism::Node prism_root) -> void
+    def collect_dynamic_ivar_attr_exclusions: (Prism::Node prism_root) -> void
+    def collect_inherited_attr_exclusions: (Prism::Node prism_root) -> void
+    def collect_string_literal_mentions: (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

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

@@ -42,13 +42,15 @@ module Ryac
 
     def merge_blind_def_groups: () -> void
 
+    def exclude_uncalled_methods: () -> 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 assign_short_names: (Hash[scope_id, Set[String]] scope_vars, ?TypeOracle? oracle) -> void
     def verify_no_shadowing!: (?hierarchy hierarchy) -> void
 
     def short_name_for: ([Integer, Integer] node_location_key) -> String?
@@ -67,7 +69,6 @@ module Ryac
 
     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]]
 

data/sig/ryac/analysis/type_oracle.rbs

@@ -4,7 +4,7 @@ module Ryac
   type tp_genv = TypeProf::Core::GlobalEnv
 
   class TypeOracle
-    def self.boot: (String content, Hash[String, String] rbs_files) -> TypeOracle
+    def self.boot: (String content, Hash[String, String] rbs_files, Prism::ProgramNode prism_root) -> TypeOracle
     def self.raw_prism_node: (tp_node node) -> Prism::Node?
 
     class CallerInfo

data/sig/ryac/driver_file.rbs

@@ -0,0 +1,8 @@
+module Ryac
+  module DriverFile
+    HEADER: String
+    FOOTER: String
+
+    def self.split: (String full_content) -> [String, String]
+  end
+end