ryac 0.2.0

data/lib/ryac/pipeline/concatenator.rb

@@ -0,0 +1,248 @@
+# frozen_string_literal: true
+
+require 'tsort'
+
+module Ryac
+  module Pipeline
+    # Stage 2: File Concatenation
+    # Performs topological sort and concatenates files in dependency order
+    class Concatenator
+      # @param graph [DependencyGraph] From Stage 1
+      # @return [ConcatenatedSource] Ordered, concatenated source
+      # @raise [CircularDependencyError] If cycle detected in graph
+      def call(graph)
+        sorted_paths = topological_sort(graph)
+        concatenate_files(graph, sorted_paths)
+      end
+
+      private
+
+      # Perform topological sort using Ruby's TSort library
+      # @return [Array<String>] Paths in dependency order (dependencies first)
+      def topological_sort(graph)
+        sorter = GraphSorter.new(graph)
+        begin
+          sorter.tsort
+        rescue TSort::Cyclic
+          # Extract cycle from error message
+          cycle = extract_cycle_from_graph(graph)
+          raise CircularDependencyError.new(cycle)
+        end
+      end
+
+      # Extract cycle path from graph for error reporting
+      def extract_cycle_from_graph(graph)
+        visited = Set.new
+        rec_stack = Set.new
+        path = [] #: Array[String]
+
+        graph.paths.each do |start|
+          if find_cycle_dfs(graph, start, visited, rec_stack, path)
+            return path
+          end
+        end
+
+        # Fallback: return all paths
+        graph.paths
+      end
+
+      def find_cycle_dfs(graph, node, visited, rec_stack, path)
+        return false if visited.include?(node)
+
+        visited.add(node)
+        rec_stack.add(node)
+        path << node
+
+        entry = graph[node]
+        deps = entry&.dependencies
+        if deps
+          deps.each do |dep|
+            if rec_stack.include?(dep)
+              path << dep
+              return true
+            end
+
+            if find_cycle_dfs(graph, dep, visited, rec_stack, path)
+              return true
+            end
+          end
+        end
+
+        rec_stack.delete(node)
+        path.pop
+        false
+      end
+
+      # Helper class for TSort
+      class GraphSorter
+        include TSort
+
+        def initialize(graph)
+          @graph = graph
+        end
+
+        def tsort_each_node(&block)
+          @graph.paths.each(&block)
+        end
+
+        def tsort_each_child(node, &block)
+          entry = @graph[node]
+          return unless entry
+
+          entry.dependencies.each(&block)
+          entry.in_class_dependencies.each(&block)
+        end
+      end
+
+      # Concatenate files in sorted order
+      def concatenate_files(graph, sorted_paths)
+        content_parts = [] #: Array[String]
+        file_boundaries = [] #: Array[FileBoundary]
+        stdlib_requires = [] #: Array[String]
+        inlined = Set.new
+        current_line = 1
+
+        # 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)
+          cleaned_cache[path] = process_require_statements(entry, graph, inlined, cleaned_cache)
+        end
+
+        sorted_paths.each do |path|
+          next if inlined.include?(path)
+          entry = graph[path]
+          next unless entry
+
+          cleaned_content = cleaned_cache[path]
+          lines = cleaned_content.count("\n") + 1
+
+          file_boundaries << FileBoundary.new(
+            path: path,
+            start_line: current_line,
+            end_line: current_line + lines - 1
+          )
+
+          content_parts << cleaned_content
+          current_line += lines
+        end
+
+        original_size = graph.files.values.sum { |f| f.content.bytesize }
+
+        ConcatenatedSource.new(
+          content: content_parts.join("\n"),
+          file_boundaries: file_boundaries,
+          original_size: original_size,
+          stdlib_requires: stdlib_requires.uniq,
+          rbs_files: graph.rbs_files
+        )
+      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
+      # guarded — optcarrot loads stackprof only under --stackprof-mode, so
+      # hoisting it turns an optional dependency into a mandatory one.
+      def collect_stdlib_requires(entry, stdlib_requires)
+        entry.require_nodes.each do |node|
+          next unless node[:type] == :require_stdlib
+          next if node[:in_method]
+          stdlib_requires << node[:path]
+        end
+      end
+
+      # Process require statements: remove top-level requires, inline in-class requires
+      def process_require_statements(entry, graph, inlined, cleaned_cache)
+        content = entry.content
+        require_nodes = entry.require_nodes
+        return content if require_nodes.empty?
+
+        in_class_deps = entry.in_class_dependencies.to_set
+        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)
+        else
+          line_based_processing(content, require_nodes)
+        end
+      end
+
+      def offset_based_processing(content, nodes, graph, in_class_deps, inlined, cleaned_cache)
+        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.
+        result = content.b
+        sorted_nodes.each do |node|
+          start_pos = node[:start_offset]
+          end_pos = start_pos + node[:length]
+
+          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
+              stripped = strip_outer_nesting(dep_content)
+              # Only consume trailing semicolons (not newlines) for inline
+              while end_pos < result.size && result[end_pos] == ';'
+                end_pos += 1
+              end
+              result[start_pos...end_pos] = stripped.b
+              inlined.add(dep_path)
+              next
+            end
+          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]
+
+          # For removal: consume trailing semicolons and newlines
+          while end_pos < result.size && (result[end_pos] == ';' || result[end_pos] == "\n")
+            end_pos += 1
+          end
+          result[start_pos...end_pos] = ''
+        end
+        result.force_encoding(content.encoding)
+      end
+
+      def line_based_processing(content, require_nodes)
+        lines = content.lines
+        lines_to_remove = Set.new
+        require_nodes.each { |node| lines_to_remove.add(node[:line] - 1) }
+        lines.each_with_index.map do |line, idx|
+          lines_to_remove.include?(idx) ? '' : line.chomp
+        end.join("\n")
+      end
+
+      def resolve_node_path(node, graph)
+        resolved = node[:resolved_path]
+        return nil unless resolved
+        graph.files.key?(resolved) ? resolved : nil
+      end
+
+      # Strip outer module/class nesting from a file so it can be inlined
+      # inside the parent's class body. Peels single-child module/class layers
+      # until reaching the innermost new scope definition.
+      def strip_outer_nesting(content)
+        ast = Prism.parse(content).value
+        node = ast.statements
+        while node.is_a?(Prism::StatementsNode) && node.body.size == 1
+          child = node.body.first
+          break unless child.is_a?(Prism::ModuleNode) || child.is_a?(Prism::ClassNode)
+          inner_body = child.body
+          if inner_body.is_a?(Prism::StatementsNode) && inner_body.body.size == 1
+            inner_child = inner_body.body.first
+            if inner_child.is_a?(Prism::ModuleNode) || inner_child.is_a?(Prism::ClassNode)
+              node = inner_body
+              next
+            end
+          end
+          break
+        end
+        node.slice
+      end
+    end
+  end
+end

data/lib/ryac/pipeline/constant_aliaser.rb

@@ -0,0 +1,240 @@
+# frozen_string_literal: true
+
+require 'set'
+
+module Ryac
+  module Pipeline
+    # Constant aliasing via source patching.
+    class ConstantAliaser < Stage
+      include RenamePatcher
+
+      def needs_analysis? = true
+
+      def initialize(rename_classes: false)
+        @rename_classes = rename_classes
+      end
+
+      def collect(ctx, patches)
+        analysis = analysis(ctx)
+        @class_module_cpath_offsets = Set.new
+        # Declared optional on AnalysisResult but always present by the time
+        # constant patches are collected.
+        @constant_mapping = analysis.constant_mapping #: ConstantRenameMapping
+        # Short-name assignment is this stage's policy — it happens exactly
+        # once, before any constant patch is emitted, and no other stage
+        # reads the mapping.
+        if @constant_mapping
+          generator = NameGenerator.new([], upcase: true)
+          @constant_mapping.assign_short_names(generator, skip_class_modules: !@rename_classes)
+        end
+        collect_patches(ctx.ast, patches, analysis)
+      end
+
+      def finish(ctx)
+        mapping = @constant_mapping
+        return unless mapping
+
+        prefix_decls = mapping.generate_prefix_declarations
+        ctx.preamble = [ctx.preamble, prefix_decls.join(';')].reject(&:empty?).join(';') if prefix_decls.any?
+
+        alias_decls = mapping.generate_alias_declarations
+        ctx.aliases = [ctx.aliases, alias_decls.join(';')].reject(&:empty?).join(';') if alias_decls.any?
+      end
+
+      private
+
+      def collect_patches(node, patches, analysis)
+        walk_prism(node) do |subnode|
+          case subnode
+          when Prism::ConstantReadNode
+            patch_constant_ref(subnode, patches, analysis)
+          when Prism::ConstantPathNode
+            patch_constant_ref(subnode, patches, analysis)
+            next :skip_children
+          when Prism::ConstantWriteNode
+            patch_constant_write(subnode, patches, analysis)
+          when Prism::ConstantTargetNode
+            # `A, B = ...` — Prism models each target as a ConstantTargetNode,
+            # not a ConstantWriteNode. TypeProf still reports one constant per
+            # target at the same location, so without this the references get
+            # renamed while the definitions keep their original names.
+            patch_constant_write(subnode, patches, analysis)
+          when Prism::ConstantPathWriteNode
+            patch_constant_path_write(subnode, patches, analysis)
+          when Prism::ClassNode
+            patch_class_node(subnode, patches, analysis)
+          when Prism::ModuleNode
+            patch_module_node(subnode, patches, analysis)
+          when Prism::DefNode
+            patch_def_receiver(subnode.receiver, patches, analysis) if subnode.receiver && !subnode.receiver.is_a?(Prism::SelfNode)
+          end
+        end
+      end
+
+      def patch_constant_ref(node, patches, analysis)
+        return if @class_module_cpath_offsets.include?(node.location.start_offset)
+
+        key = prism_location_key(node)
+        resolved_cpath = analysis.const_resolution_map[key]
+        full_path = analysis.const_full_path_map[key]
+        prefix_alias = full_path && @constant_mapping&.short_name_for_prefix(full_path)
+
+        if resolved_cpath && @constant_mapping&.user_defined_path?(resolved_cpath)
+          short = if node.is_a?(Prism::ConstantReadNode)
+            # Bare name reference (e.g., CONST) — use only the leaf short name.
+            # Expanding to a fully qualified path would break constants defined
+            # in `class << self` (metaclass constants are not accessible as Foo::X).
+            @constant_mapping.short_name_for_path(resolved_cpath) || node.name.to_s
+          else
+            get_short_cpath(resolved_cpath)
+          end
+          loc = node.location
+          patches << { start: loc.start_offset, end: loc.end_offset, replacement: short }
+        elsif node.is_a?(Prism::ConstantPathNode) && resolved_cpath &&
+              (short = build_renamed_via_user_prefix(node, analysis))
+          loc = node.location
+          patches << { start: loc.start_offset, end: loc.end_offset, replacement: short }
+        elsif prefix_alias
+          short = "#{prefix_alias}::#{node.name}"
+          loc = node.location
+          patches << { start: loc.start_offset, end: loc.end_offset, replacement: short }
+        end
+      end
+
+      def patch_constant_write(node, patches, analysis)
+        key = prism_location_key(node)
+        static_cpath = analysis.const_write_cpath_map[key]
+        return unless static_cpath
+
+        short_name = @constant_mapping.short_name_for_path(static_cpath)
+        return unless short_name
+
+        # A ConstantTargetNode is entirely the name; a ConstantWriteNode also
+        # spans `= value`, so only its name_loc belongs to us.
+        name_loc = node.is_a?(Prism::ConstantTargetNode) ? node.location : node.name_loc
+        patches << { start: name_loc.start_offset, end: name_loc.end_offset, replacement: short_name }
+      end
+
+      def patch_constant_path_write(node, patches, analysis)
+        key = prism_location_key(node)
+        static_cpath = analysis.const_write_cpath_map[key]
+        return unless static_cpath
+
+        path_str = render_short_cpath(static_cpath)
+        target_loc = node.target.location
+        patches << { start: target_loc.start_offset, end: target_loc.end_offset, replacement: path_str }
+        @class_module_cpath_offsets << target_loc.start_offset
+        mark_constant_children(node.target)
+      end
+
+      def patch_class_node(node, patches, analysis)
+        key = prism_location_key(node)
+        patch_definition_path(node, patches, analysis.class_cpath_map[key], analysis)
+
+        if node.superclass
+          superclass_path = analysis.superclass_resolution_map[key]
+          superclass_path ||= analysis.const_resolution_map[prism_location_key(node.superclass)]
+          if superclass_path
+            short = get_short_cpath(superclass_path)
+            sc_loc = node.superclass.location
+            patches << { start: sc_loc.start_offset, end: sc_loc.end_offset, replacement: short }
+            @class_module_cpath_offsets << sc_loc.start_offset
+            mark_constant_children(node.superclass)
+          end
+        end
+      end
+
+      def patch_module_node(node, patches, analysis)
+        patch_definition_path(node, patches, analysis.class_cpath_map[prism_location_key(node)], analysis)
+      end
+
+      # A definition's written path names the class relative to its lexical
+      # nesting, and the enclosing modules are renamed right along with it —
+      # so the renamed spelling only needs the written segments' short names.
+      # Re-qualifying with the full path (`module A; class A::B`) costs bytes
+      # and says nothing the nesting doesn't already say: `class B` inside
+      # `module A` creates and reopens exactly A::B.
+      def patch_definition_path(node, patches, class_cpath, analysis)
+        return unless class_cpath
+
+        # class_cpath exists only when path_segments succeeded on this node,
+        # and in the absolute case it equals the segments outright.
+        segments, = Nesting.path_segments(node.constant_path) #: [Array[Symbol], bool]
+        rendered = render_short_cpath(class_cpath, from: class_cpath.size - segments.size)
+        if rendered != node.constant_path.slice
+          cpath_loc = node.constant_path.location
+          patches << { start: cpath_loc.start_offset, end: cpath_loc.end_offset, replacement: rendered }
+        end
+
+        @class_module_cpath_offsets << node.constant_path.location.start_offset
+        mark_constant_children(node.constant_path)
+      end
+
+      # Each prefix of the cpath may carry its own short name; render from
+      # `from` onward, falling back to the original segment where none was
+      # assigned.
+      def render_short_cpath(cpath, from: 0)
+        (from...cpath.size).map { |i|
+          @constant_mapping.short_name_for_path(cpath[0..i]) || cpath[i].to_s
+        }.join('::')
+      end
+
+      def mark_constant_children(node)
+        case node
+        when Prism::ConstantPathNode
+          @class_module_cpath_offsets << node.location.start_offset
+          mark_constant_children(node.parent) if node.parent
+        when Prism::ConstantReadNode
+          @class_module_cpath_offsets << node.location.start_offset
+        end
+      end
+
+      def build_renamed_via_user_prefix(node, analysis)
+        parent_node = node.parent
+        return nil unless parent_node
+
+        parent_key = prism_location_key(parent_node)
+        parent_resolved = analysis.const_resolution_map[parent_key]
+        return nil unless parent_resolved
+
+        if @constant_mapping.user_defined_path?(parent_resolved)
+          parent_short = if parent_node.is_a?(Prism::ConstantReadNode)
+            @constant_mapping.short_name_for_path(parent_resolved) || parent_node.name.to_s
+          else
+            get_short_cpath(parent_resolved)
+          end
+          "#{parent_short}::#{node.name}"
+        elsif parent_node.is_a?(Prism::ConstantPathNode)
+          parent_renamed = build_renamed_via_user_prefix(parent_node, analysis)
+          parent_renamed ? "#{parent_renamed}::#{node.name}" : nil
+        end
+      end
+
+      def get_short_cpath(cpath)
+        if @constant_mapping.user_defined_path?(cpath)
+          render_short_cpath(cpath)
+        else
+          cpath.map(&:to_s).join('::')
+        end
+      end
+
+      def patch_def_receiver(receiver, patches, analysis)
+        return unless @constant_mapping
+
+        @class_module_cpath_offsets.add(receiver.location.start_offset)
+        key = prism_location_key(receiver)
+        resolved_cpath = case receiver
+                         when Prism::ConstantReadNode
+                           analysis.const_resolution_map[key] || [receiver.name]
+                         when Prism::ConstantPathNode
+                           analysis.const_resolution_map[key]
+                         end
+        return unless resolved_cpath && @constant_mapping.user_defined_path?(resolved_cpath)
+
+        short = get_short_cpath(resolved_cpath)
+        loc = receiver.location
+        patches << { start: loc.start_offset, end: loc.end_offset, replacement: short }
+      end
+    end
+  end
+end

data/lib/ryac/pipeline/constant_fold.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module Ryac
+  module Pipeline
+    class ConstantFold < Stage
+      FOLDABLE_OPS = %i[+ - * / % ** << >> & | ^].freeze
+      INTEGER_ONLY_OPS = %i[<< >> & | ^].freeze
+
+      def collect(ctx, patches)
+        walk(ctx.ast, patches)
+      end
+
+      private
+
+      def walk(node, patches)
+        if node.is_a?(Prism::CallNode)
+          folded = try_constant_fold(node)
+          if folded
+            replacement = folded.to_s
+            if replacement.bytesize < node.location.length
+              patches << mk(node, replacement)
+              return
+            end
+          end
+        end
+        node.compact_child_nodes.each { |child| walk(child, patches) }
+      end
+
+      def try_constant_fold(node)
+        case node
+        when Prism::IntegerNode then node.value
+        when Prism::FloatNode then node.value
+        when Prism::ParenthesesNode
+          body = node.body
+          if body.is_a?(Prism::StatementsNode) && body.body.size == 1
+            try_constant_fold(body.body.first)
+          end
+        when Prism::CallNode
+          if node.receiver && node.arguments.nil? && node.name == :-@
+            inner = try_constant_fold(node.receiver)
+            return nil unless inner.is_a?(Numeric)
+            -inner
+          else
+            try_fold_binary_op(node)
+          end
+        end
+      end
+
+      def try_fold_binary_op(node)
+        return nil unless node.receiver
+        return nil unless node.arguments&.arguments&.size == 1
+        return nil if node.block
+
+        op = node.name
+        return nil unless FOLDABLE_OPS.include?(op)
+
+        lhs = try_constant_fold(node.receiver)
+        return nil unless lhs.is_a?(Numeric)
+
+        # arguments proved non-nil above
+        rhs = try_constant_fold(node.arguments.arguments.first) # steep:ignore NoMethod
+        return nil unless rhs.is_a?(Numeric)
+
+        return nil if INTEGER_ONLY_OPS.include?(op) && !(lhs.is_a?(Integer) && rhs.is_a?(Integer))
+        return nil if (op == :/ || op == :%) && rhs == 0
+
+        result = apply_op(lhs, op, rhs)
+        return nil unless result.is_a?(Integer) || result.is_a?(Float)
+        return nil if result.is_a?(Float) && (result.nan? || result.infinite?)
+
+        result
+      rescue StandardError
+        nil
+      end
+
+      def apply_op(lhs, op, rhs)
+        case op
+        when :+ then lhs + rhs
+        when :- then lhs - rhs
+        when :* then lhs * rhs
+        when :/ then lhs / rhs
+        when :% then lhs % rhs
+        when :** then lhs ** rhs
+        when :<< then lhs << rhs
+        when :>> then lhs >> rhs
+        when :& then lhs & rhs
+        when :| then lhs | rhs
+        when :^ then lhs ^ rhs
+        end
+      end
+    end
+  end
+end