ryac 0.2.0

data/lib/ryac/analysis/method_aliases.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module Ryac
+  # Method alias mappings: longer method name => shorter equivalent
+  # TypeProf verifies at analysis time that the shorter method
+  # is available on the receiver type via inheritance chain.
+  #
+  # SELF-HOSTING NOTE: these rewrites fire only where inference proves
+  # the receiver, and inference over lib/'s own source can shift between
+  # self-hosting passes; the integration suite's fixed-point check is what
+  # catches a rewrite firing on one pass only.
+  # Object/Kernel aliases where both spellings name the same method on
+  # EVERY receiver — the only rows safe on a receiverless call, which
+  # dispatches on whatever self happens to be.
+  KERNEL_ALIASES = {
+    kind_of?:   :is_a?,
+    yield_self: :then,
+    object_id:  :__id__,
+    raise:      :fail,
+  }.freeze
+
+  # Receiver-specific synonyms (Enumerable/Hash/String/...): a receiverless
+  # spelling can name something else entirely (`include?` in a class body is
+  # Module#include?), so these fire only when inference proves the receiver
+  # responds to the short spelling.
+  RECEIVER_ALIASES = {
+    collect:        :map,
+    collect!:       :map!,
+    detect:         :find,
+    find_all:       :select,
+    collect_concat: :flat_map,
+    each_pair:      :each,
+    has_key?:       :key?,
+    has_value?:     :value?,
+    find_index:     :index,
+    magnitude:      :abs,
+    id2name:        :to_s,
+    length:         :size,
+    entries:        :to_a,
+    append:         :push,
+    include?:       :key?,
+    member?:        :key?,
+  }.freeze
+
+  METHOD_ALIASES = KERNEL_ALIASES.merge(RECEIVER_ALIASES).freeze
+
+  # The literal an emptiness rewrite compares against, per receiver type —
+  # the single fact both transform tables below build on.
+  EMPTY_LITERALS = { Array: '[]', String: '""', Hash: '{}' }.freeze
+
+  # Structural method transforms: method call → different syntax
+  # Applied only when TypeProf verifies receiver type compatibility.
+  # Key: [method_name, :ClassName], Value: replacement string
+  METHOD_TRANSFORMS = {
+    [:first, :Array] => '[0]',
+    [:zero?, :Numeric] => '==0',
+    **EMPTY_LITERALS.to_h { |type, lit| [[:empty?, type], "==#{lit}"] },
+  }.freeze
+
+  # The comparison operators the size-comparison transforms recognize, and
+  # the spelling each takes in the rewrite: `> 0` means non-empty for a
+  # size, so it shares the != spelling.
+  SIZE_COMPARISON_OPS = { :== => '==', :!= => '!=', :> => '!=' }.freeze
+
+  # Whole-comparison transforms: `.size==0` and friends collapse to a
+  # literal comparison under the same receiver-type gate as the empty?
+  # rows, one call deeper. Key: [comparison_op, :ClassName], value: the
+  # replacement for `.mid op 0`.
+  SIZE_COMPARISON_TRANSFORMS = SIZE_COMPARISON_OPS.each_with_object(
+    {} #: Hash[[Symbol, Symbol], String]
+  ) { |(op, spelled), table|
+    EMPTY_LITERALS.each { |type, lit| table[[op, type]] = "#{spelled}#{lit}" }
+  }.freeze
+
+  # The inner calls those comparisons recognize, with the types where the
+  # no-argument form means size. String#count requires an argument, so a
+  # bare .count is never a String size query.
+  SIZE_QUERY_MIDS = {
+    size: %i[Array String Hash],
+    length: %i[Array String Hash],
+    count: %i[Array Hash],
+  }.freeze
+end

data/lib/ryac/analysis/method_aliasing.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Ryac
+  module AnalysisPhases
+    def resolve_method_aliases_and_transforms(prism_root)
+      alias_map = {} #: Hash[location_key, Symbol]
+      transform_map = {} #: Hash[location_key, String]
+      suppressed_alias_keys = [] #: Array[location_key]
+      AstUtils.each_node(prism_root) do |node|
+        next unless node.is_a?(Prism::CallNode)
+
+        if node.receiver
+          shorter = METHOD_ALIASES[node.name]
+          alias_map[AstUtils.location_key(node)] = shorter if shorter && @oracle.receiver_responds_to?(node, shorter)
+        else
+          shorter = KERNEL_ALIASES[node.name]
+          alias_map[AstUtils.location_key(node)] = shorter if shorter
+        end
+
+        if node.receiver && (node.arguments.nil? || node.arguments.arguments.empty?)
+          METHOD_TRANSFORMS.each do |(mid, type_name), replacement|
+            next unless mid == node.name
+            if @oracle.receiver_within_type?(node, type_name)
+              transform_map[AstUtils.location_key(node)] = replacement
+              break
+            end
+          end
+        end
+
+        register_size_comparison(node, transform_map, suppressed_alias_keys)
+      end
+      # A comparison transform swallows its inner size call whole — an
+      # alias patch on that call would overlap it.
+      suppressed_alias_keys.each { |k| alias_map.delete(k) }
+      [alias_map, transform_map]
+    end
+
+    private
+
+    # `.size==0` (and !=0 / >0) against a proven receiver collapses to the
+    # literal comparison. Registered on the comparison node; the renamer
+    # patches from the data receiver through the comparison's end.
+    def register_size_comparison(node, transform_map, suppressed_alias_keys)
+      return unless SIZE_COMPARISON_OPS.key?(node.name)
+
+      inner = node.receiver
+      return unless inner.is_a?(Prism::CallNode)
+      return unless inner.receiver && inner.call_operator_loc && !inner.safe_navigation?
+      return unless inner.arguments.nil? && inner.block.nil?
+
+      types = SIZE_QUERY_MIDS[inner.name]
+      return unless types
+
+      args = node.arguments&.arguments
+      return unless args && args.size == 1 && args[0].is_a?(Prism::IntegerNode) && args[0].value == 0
+
+      types.each do |type_name|
+        next unless @oracle.receiver_within_type?(inner, type_name)
+        transform_map[AstUtils.location_key(node)] = SIZE_COMPARISON_TRANSFORMS.fetch([node.name, type_name])
+        suppressed_alias_keys << AstUtils.location_key(inner)
+        break
+      end
+    end
+  end
+end

data/lib/ryac/analysis/nesting.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+module Ryac
+  # Closed-world walk of the Prism tree with the class/module nesting tracked.
+  #
+  # The nesting is a lexical fact: `class B::C` under [:M, :A] defines
+  # [:M, :A, :B, :C] — verified against TypeProf, which concatenates the
+  # written path onto the enclosing nesting exactly like this rather than
+  # resolving `B` first. Defs and `class << self` do not change it. The one
+  # thing that cannot be computed here is a dynamic path (`class self::X`,
+  # `class << other`); those bodies are not descended into, which errs on the
+  # side of leaving their contents unrenamed.
+  module Nesting
+    module_function
+
+    # Yields every node together with the enclosing [cpath, singleton, in_def]
+    # — singleton is true inside `class << self`, in_def inside a method body.
+    def each(root, &block)
+      walk(root, [], false, false, &block)
+    end
+
+    # Yields meta-style declarations (`attr_reader :a` / `include M`) under
+    # the conditions type analysis recognizes them: a bare call in statement
+    # position directly in a class or module body (or `class << self`),
+    # outside any def. Passing loose: true drops everything but the bare-call
+    # requirement — for consumers where over-matching is the safe direction.
+    def each_meta_call(root, names, loose: false)
+      if loose
+        each(root) do |node, cpath, singleton, _in_def|
+          next unless node.is_a?(Prism::CallNode) && node.receiver.nil? && names.include?(node.name)
+
+          yield node, cpath, singleton
+        end
+      else
+        each(root) do |node, cpath, singleton, in_def|
+          next unless node.is_a?(Prism::StatementsNode)
+          next if in_def
+          # any? rather than empty?: the type-dependent empty? transform does
+          # not reach a fixed point on this code under self-hosting.
+          next unless cpath.any? || singleton
+
+          node.body.each do |child|
+            next unless child.is_a?(Prism::CallNode) && child.receiver.nil? && names.include?(child.name)
+
+            yield child, cpath, singleton
+          end
+        end
+      end
+    end
+
+    # Yields every method definition with its [cpath, singleton, name] key:
+    # the receiver form folded in (`def self.x` and defs inside `class <<
+    # self` are singleton; `def Foo.x` defines on Foo wherever it lexically
+    # sits), so every collection computes method identity the same way.
+    def each_method_definition(root)
+      each(root) do |node, cpath, sclass_singleton, _in_def|
+        next unless node.is_a?(Prism::DefNode)
+
+        singleton = sclass_singleton || !node.receiver.nil?
+        key_cpath = cpath
+        receiver = node.receiver
+        if receiver && !receiver.is_a?(Prism::SelfNode)
+          segments, _absolute = path_segments(receiver)
+          key_cpath = segments if segments
+        end
+        yield node, [key_cpath, singleton, node.name].freeze # steep:ignore ArgumentTypeMismatch
+      end
+    end
+
+    # The written segments of a qualified constant — a class/module name, an
+    # assignment target, a def receiver. Returns [segments, absolute] —
+    # absolute when written `::X` — or nil when the path is not statically
+    # known (`self::X`, `expr::X`).
+    def path_segments(constant_path)
+      segments = [] #: Array[Symbol]
+      current = constant_path
+      while current.is_a?(Prism::ConstantPathNode) || current.is_a?(Prism::ConstantPathTargetNode)
+        # Prism types #name as Symbol? only for parse-degenerate paths.
+        segments.unshift(current.name) # steep:ignore ArgumentTypeMismatch
+        current = current.parent
+      end
+
+      case current
+      when Prism::ConstantReadNode
+        [segments.unshift(current.name), false]
+      when nil
+        [segments, true]
+      end
+    end
+
+    def walk(node, cpath, singleton, in_def, &block)
+      return unless node.is_a?(Prism::Node)
+
+      yield node, cpath, singleton, in_def
+
+      case node
+      when Prism::ClassNode, Prism::ModuleNode
+        # The name path is walked too: its segments are constant references
+        # in their own right (counted and aliased like any other).
+        walk(node.constant_path, cpath, singleton, in_def, &block)
+        walk(node.superclass, cpath, singleton, in_def, &block) if node.is_a?(Prism::ClassNode) && node.superclass
+        segments, absolute = path_segments(node.constant_path)
+        return unless segments
+
+        inner = absolute ? segments : cpath + segments
+        walk(node.body, inner, false, false, &block)
+      when Prism::SingletonClassNode
+        walk(node.expression, cpath, singleton, in_def, &block)
+        return unless node.expression.is_a?(Prism::SelfNode)
+
+        walk(node.body, cpath, true, in_def, &block)
+      when Prism::DefNode
+        # The receiver of `def Foo.bar` is deliberately not walked: type
+        # analysis has no nodes there, and every renamer that cares reads
+        # node.receiver off the def itself.
+        walk(node.parameters, cpath, singleton, true, &block)
+        walk(node.body, cpath, singleton, true, &block)
+      else
+        node.compact_child_nodes.each { |child| walk(child, cpath, singleton, in_def, &block) }
+      end
+    end
+  end
+end

data/lib/ryac/analysis/scope_management.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Ryac
+  # Two different variables of one scope collapsing into one name silently
+  # changes what the code computes, and the result still parses — the
+  # self-hosted minifier once emitted `def c(a) = c(a) || d(a)` this way. Every
+  # scope mapping passes through here before it is used, so a collision fails
+  # the run instead of shipping.
+  #
+  # Its own module so LocalScopes can include just this: including
+  # AnalysisPhases would graft dozens of phase methods onto it as
+  # ancestors, which under self-hosting entangles its rename groups with
+  # the mixin's.
+  module RenameInvariants
+    def verify_injective!(mapping, scope_label)
+      return if mapping.size < 2
+
+      collisions = mapping.group_by { |_, short| short }
+                          .filter_map { |short, pairs| [short, pairs.map(&:first)] if pairs.size > 1 } #: Array[[String, Array[Symbol]]]
+      return if collisions.empty?
+
+      raise Pipeline::RenameCollisionError.new(scope_label, collisions)
+    end
+  end
+end

data/lib/ryac/analysis/site_bucket_mapping.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module Ryac
+  # One (cpath, name) → sites table for the sigil families: instance and
+  # class variables differ only in their sigil, and a name of sigil + one
+  # character is already minimal.
+  #
+  # Buckets merge along inheritance, and the merge records an alias so a
+  # site added afterwards lands in the merged bucket instead of silently
+  # resurrecting the child's. After assign_short_names the table is sealed:
+  # anything arriving later would miss renaming, so the phase that got its
+  # order wrong fails loudly instead.
+  class SiteBucketMapping
+    def initialize(prefix:)
+      @prefix = prefix
+      @kept_name_max = prefix.size + 1
+      @buckets = {}
+      @cpath_to_canonical = {}
+      @excluded_cpaths = Set.new
+      @reserved_names = {}
+      @node_short_names = {}
+      @frozen = false
+    end
+
+    def add_site(cpath, name, node)
+      check_open!('site added')
+      canonical = resolve_canonical(cpath)
+      @buckets[canonical] ||= {}
+      (@buckets[canonical][name] ||= []) << node
+    end
+
+    def exclude_cpath(cpath)
+      check_open!('cpath excluded')
+      @excluded_cpaths << resolve_canonical(cpath)
+    end
+
+    def reserve_name(cpath, short_name)
+      check_open!('name reserved')
+      canonical = resolve_canonical(cpath)
+      @reserved_names[canonical] ||= Set.new
+      @reserved_names[canonical] << short_name
+    end
+
+    def each_canonical_cpath(&block)
+      @buckets.each_key(&block)
+    end
+
+    def merge_with_ancestor(child_cpath, ancestor_cpath)
+      check_open!('merge')
+      child_canonical = resolve_canonical(child_cpath)
+      ancestor_canonical = resolve_canonical(ancestor_cpath)
+      return if child_canonical == ancestor_canonical
+      return unless @buckets.key?(ancestor_canonical)
+
+      child_entry = @buckets[child_canonical]
+      return unless child_entry
+
+      # Recorded before the sites move: from here on, a site added for the
+      # child cpath belongs to the merged bucket.
+      @cpath_to_canonical[child_canonical] = ancestor_canonical
+
+      ancestor_entry = @buckets[ancestor_canonical]
+      child_entry.keys.each do |name|
+        child_nodes = child_entry.delete(name)
+        next unless child_nodes
+        if ancestor_entry.key?(name)
+          ancestor_entry[name].concat(child_nodes)
+        else
+          ancestor_entry[name] = child_nodes
+        end
+      end
+
+      @buckets.delete(child_canonical) if child_entry.none?
+    end
+
+    def assign_short_names
+      @buckets.each do |cpath, names|
+        next if @excluded_cpaths.include?(cpath)
+
+        existing_names = Set.new
+        names.each_key do |name|
+          existing_names << name.to_s if name.to_s.size <= @kept_name_max
+        end
+        reserved = @reserved_names[cpath]
+        existing_names.merge(reserved) if reserved
+
+        generator = NameGenerator.new(existing_names, prefix: @prefix)
+        sorted = names.sort_by do |name, nodes|
+          -(name.to_s.size * nodes.size)
+        end
+
+        sorted.each do |name, nodes|
+          next if name.to_s.size <= @kept_name_max
+
+          short_name = generator.next_name
+          savings = (name.to_s.size - short_name.size) * nodes.size
+          next unless savings > 0
+
+          nodes.each { |n| @node_short_names[AstUtils.location_key(n)] = short_name }
+        end
+      end
+      @frozen = true
+    end
+
+    def node_mapping
+      @node_short_names.dup
+    end
+
+    private
+
+    def check_open!(action)
+      raise InternalError, "#{@prefix}-mapping: #{action} after assign_short_names" if @frozen
+    end
+
+    def resolve_canonical(cpath)
+      return cpath unless @cpath_to_canonical.key?(cpath)
+
+      current = cpath
+      seen = Set.new
+      while @cpath_to_canonical.key?(current) && !seen.include?(current)
+        seen << current
+        current = @cpath_to_canonical[current]
+      end
+      current
+    end
+  end
+end