rigortype 0.3.9 → 0.4.0

data/lib/rigor/sig_gen/writer.rb

@@ -31,12 +31,16 @@ module Rigor
 
       # Per-`update_existing` accumulator. The merge_class helper mutates `source` / `decls` / `applied` /
       # `skipped` in place as each class is processed so the next class sees the latest byte positions.
-      MergeState = Struct.new(:source, :decls, :applied, :skipped, keyword_init: true)
+      MergeState = Struct.new(:source, :decls, :applied, :skipped, :left_unreadable, :replaced, keyword_init: true)
       private_constant :MergeState
 
-      def initialize(path_mapper:, overwrite: false)
+      # @param dry_run — assemble and validate every target exactly as a write would, and report it, without
+      #   creating or changing a file. `sig-gen --check` (ADR-112 WD4) is this, so it can only ever disagree
+      #   with `--write` about the disk, never about the content.
+      def initialize(path_mapper:, overwrite: false, dry_run: false)
         @path_mapper = path_mapper
         @overwrite = overwrite
+        @dry_run = dry_run
         # Run-level (cross-file) namespace-kind view, populated per `#write_all` from every candidate's per-file
         # map. Empty until then so the single-target `#write` path falls back to per-candidate kinds only.
         @global_namespace_kinds = {}
@@ -74,6 +78,15 @@ module Rigor
         write_target(target, emittable, source_path: source_path)
       end
 
+      # Whether `proposed` has STRICTLY FEWER bare `untyped` tokens than `existing`. A count, not a slot-by-slot
+      # comparison: it reads as "at least one more position is concrete", and does not prove that no concrete
+      # position became `untyped` elsewhere. Word-boundary matching counts `untyped` only as a type token, not
+      # as a substring inside identifiers. Public because the generator asks the same question before it lists a
+      # declared `initialize` at all (#1436).
+      def self.fewer_untyped?(proposed, existing)
+        proposed.scan(/\buntyped\b/).size < existing.scan(/\buntyped\b/).size
+      end
+
       private
 
       # Shared per-target write path used by both `#write` and `#write_all`. Picks a representative
@@ -91,7 +104,7 @@ module Rigor
       # Deliberately NARROWER than {Classification::EMITTABLE}: the write path has never produced a
       # `:new_file` row (the generator does not classify one), and admitting it here would let a
       # classification with no writer behind it decide that a target file must be created.
-      EMITTABLE = [Classification::NEW_METHOD, Classification::TIGHTER_RETURN].freeze
+      EMITTABLE = [Classification::NEW_METHOD, Classification::TIGHTER_RETURN, Classification::INLINE_OVERWRITE].freeze
       private_constant :EMITTABLE
 
       def inside_sig_root?(target)
@@ -116,8 +129,10 @@ module Rigor
                                  action: :skipped_invalid_rbs, error: error)
         end
 
-        FileUtils.mkdir_p(target.dirname)
-        target.write(content)
+        unless @dry_run
+          FileUtils.mkdir_p(target.dirname)
+          target.write(content)
+        end
         WriteResult.new(source_path: source_path, target_path: target,
                         action: :created, applied: candidates)
       end
@@ -245,7 +260,7 @@ module Rigor
 
       def render_tree_node_body(node, kinds, supers, depth, prefix)
         inner_indent = INDENT * (depth + 1)
-        method_lines = node[:methods].map { |c| "#{inner_indent}#{c.rbs}\n" }.join
+        method_lines = node[:methods].flat_map { |c| c.rbs_lines.map { |line| "#{inner_indent}#{line}\n" } }.join
         child_blocks = node[:children].values.map do |child|
           render_tree_node(child, kinds, supers, depth + 1, prefix + [node[:name]])
         end.join
@@ -291,13 +306,15 @@ module Rigor
         decls = parse_signature(source)
         return WriteResult.new(source_path: source_path, target_path: target, action: :noop) if decls.nil?
 
-        state = MergeState.new(source: source, decls: decls, applied: [], skipped: [])
+        state = MergeState.new(source: source, decls: decls, applied: [], skipped: [], left_unreadable: [],
+                               replaced: [])
         merge_candidates(state, candidates)
 
         action = state.applied.empty? ? :noop : :updated
         unless action == :updated
           return WriteResult.new(source_path: source_path, target_path: target, action: action,
-                                 applied: state.applied, skipped: state.skipped)
+                                 applied: state.applied, skipped: state.skipped,
+                                 left_unreadable: state.left_unreadable)
         end
 
         # The merge splices text into an existing file by byte offset, so a bug here can produce a file neither
@@ -310,9 +327,10 @@ module Rigor
                                  action: :skipped_invalid_rbs, error: error)
         end
 
-        target.write(state.source)
+        target.write(state.source) unless @dry_run
         WriteResult.new(source_path: source_path, target_path: target,
-                        action: action, applied: state.applied, skipped: state.skipped)
+                        action: action, applied: state.applied, skipped: state.skipped,
+                        left_unreadable: state.left_unreadable, replaced: state.replaced)
       end
 
       # Applies every class group, then every requested shell, then normalises the layout the three steps
@@ -544,7 +562,7 @@ module Rigor
           state.applied.concat(methods)
           insert_namespace_chain(state, class_name, kinds, supers, methods)
         else
-          state.source = merge_into_existing_class(state.source, decl, methods, state.applied, state.skipped)
+          state.source = merge_into_existing_class(state.source, decl, methods, state)
           state.decls = parse_signature(state.source) || state.decls
         end
       end
@@ -575,24 +593,29 @@ module Rigor
         source.end_with?("\n")
       end
 
-      def merge_into_existing_class(source, decl, methods, applied, skipped)
+      def merge_into_existing_class(source, decl, methods, state)
         existing_pairs = collect_member_pairs(decl)
         new_methods, conflicting = partition_against_existing(methods, existing_pairs)
 
         source = insert_into_class(source, decl, new_methods)
-        applied.concat(new_methods)
+        state.applied.concat(new_methods)
 
         if @overwrite
-          source, replaced = replace_eligible_conflicts(source, decl, conflicting)
-          applied.concat(replaced)
-          skipped.concat(conflicting.reject { |c| replaced.include?(c) }.map { |c| [c, :user_authored] })
+          source, replaced = replace_eligible_conflicts(source, decl, conflicting, state)
+          state.applied.concat(replaced)
+          state.replaced.concat(replaced)
+          state.skipped.concat(conflicting.reject { |c| replaced.include?(c) }.map { |c| [c, :user_authored] })
         else
-          skipped.concat(conflicting.map { |c| [c, :user_authored] })
+          state.skipped.concat(conflicting.map { |c| [c, :user_authored] })
         end
 
         source
       end
 
+      def inline_overwrite?(candidate)
+        candidate.classification == Classification::INLINE_OVERWRITE
+      end
+
       # Returns a list of `[method_name (Symbol), kind (Symbol)]` pairs for every method-like member in the
       # declaration. ADR-14 slice 4 recognises `MethodDefinition`'s `:instance` / `:singleton` kind plus the
       # three `attr_*` declaration kinds so a source-side `attr_reader :name` and an RBS-side
@@ -628,7 +651,8 @@ module Rigor
         return source if new_methods.empty?
 
         indent = INDENT * member_indent_depth(decl)
-        insert_before_end(source, decl, new_methods.map { |c| "#{indent}#{c.rbs}\n" }.join)
+        lines = new_methods.flat_map { |c| c.rbs_lines.map { |line| "#{indent}#{line}\n" } }.join
+        insert_before_end(source, decl, lines)
       end
 
       # Walks the class's existing method declarations; for each replaceable candidate that matches a member
@@ -643,21 +667,32 @@ module Rigor
       #    canonical case is `initialize_stub_candidate`, which bypasses the existing-RBS comparison and always
       #    classifies as `NEW_METHOD` — when sig-gen's `--params=observed` upgrades a `(path: untyped) -> void`
       #    declaration to `(path: String) -> void` we want `--overwrite` to apply it.
-      def replace_eligible_conflicts(source, decl, candidates)
+      def replace_eligible_conflicts(source, decl, candidates, state)
         eligible = candidates.select { |c| eligible_for_replacement?(c, decl, source) }
         return [source, []] if eligible.empty?
 
         replaced = []
+        done = {}
         # Apply replacements from highest byte position downward so earlier byte offsets remain valid as the
         # source grows or shrinks.
-        sorted = eligible.sort_by { |c| -member_position(decl, c.method_name, c.kind) }
+        sorted = eligible.sort_by { |c| -member_position(decl, c) }
         sorted.each do |candidate|
-          source = apply_replacement(source, decl, candidate) and replaced << candidate
+          member = replaceable_member(decl, candidate)
+          # An `attr_accessor` answers for two methods; its one replacement covers both candidates.
+          next replaced << candidate if member && done[member.location.start_pos]
+
+          result = apply_replacement(source, decl, candidate, state)
+          next if result.nil?
+
+          done[member.location.start_pos] = true
+          source = result
+          replaced << candidate
         end
         [source, replaced]
       end
 
       def eligible_for_replacement?(candidate, decl, source)
+        return true if inline_overwrite?(candidate)
         return false if replaces_declared_void?(candidate, decl)
 
         case candidate.classification
@@ -684,25 +719,37 @@ module Rigor
         declared_void && !candidate.rbs.to_s.end_with?(" -> void")
       end
 
-      # Compares the existing member's source-side RBS text against the candidate's proposed RBS text. Returns
-      # true when the new spelling has STRICTLY FEWER bare `untyped` tokens than the existing one — i.e. at
-      # least one `untyped` slot becomes a concrete type AND no concrete slot becomes `untyped`. Word-boundary
-      # matching ensures we count `untyped` only as a type token, not as a substring inside identifiers.
+      # Compares the existing member's source-side RBS text against the candidate's proposed RBS text
+      # ({.fewer_untyped?}).
       def tightens_untyped?(candidate, decl, source)
         member = find_method_member(decl, candidate.method_name, candidate.kind)
         return false if member.nil?
 
-        existing_rbs = source[member.location.start_pos...member.location.end_pos]
-        count_untyped(candidate.rbs) < count_untyped(existing_rbs)
+        self.class.fewer_untyped?(candidate.rbs, source[member.location.start_pos...member.location.end_pos])
       end
 
-      def count_untyped(rbs)
-        rbs.scan(/\buntyped\b/).size
+      def member_position(decl, candidate)
+        member = replaceable_member(decl, candidate)
+        member ? member.location.start_pos : -1
       end
 
-      def member_position(decl, method_name, kind)
-        member = find_method_member(decl, method_name, kind)
-        member ? member.location.start_pos : -1
+      # The member a replacement overwrites. An inline overwrite may also land on an `attr_*` declaration of
+      # the same method (ADR-112 WD4), which it replaces in the inline attribute's own spelling; an
+      # `overloading?` member (`| ...`) is never its target.
+      def replaceable_member(decl, candidate)
+        member = find_method_member(decl, candidate.method_name, candidate.kind)
+        return member unless candidate.classification == Classification::INLINE_OVERWRITE
+
+        member = nil if member.respond_to?(:overloading?) && member.overloading?
+        member || find_attr_member(decl, candidate.method_name, candidate.kind)
+      end
+
+      def find_attr_member(decl, method_name, kind)
+        decl.members.find do |m|
+          pairs = []
+          collect_pairs_for_member(m, pairs) unless m.is_a?(RBS::AST::Members::MethodDefinition)
+          m.respond_to?(:kind) && m.kind == kind && pairs.any? { |name, _| name == method_name }
+        end
       end
 
       def find_method_member(decl, method_name, kind)
@@ -714,12 +761,96 @@ module Rigor
       # Splices the new RBS one-liner over the existing declaration's byte range. `RBS::Parser`'s location
       # starts at the `def` keyword, NOT at the column zero of the line, so the leading whitespace stays inside
       # `source[0...start_pos]` and we do not re-emit it.
-      def apply_replacement(source, decl, candidate)
-        member = find_method_member(decl, candidate.method_name, candidate.kind)
+      def apply_replacement(source, decl, candidate, state)
+        member = replaceable_member(decl, candidate)
         return nil if member.nil?
 
         loc = member.location
-        source[0...loc.start_pos] + candidate.rbs + source[loc.end_pos..]
+        replaced = source[0...loc.start_pos] + kept_comments(source, loc) + candidate.rbs + source[loc.end_pos..]
+        # Both splices insert above the member, the effect annotation at its own line and the declared ones at
+        # its first annotation's, so running the lower insertion first keeps the positions the parse gave valid.
+        replaced = splice_annotations(replaced, member, candidate, state)
+        splice_declared_annotations(replaced, member, candidate)
+      end
+
+      # A member written across lines (`def f: () -> A` / `  # why` / `  | (B) -> C`) can hold comments inside its
+      # own location, which the splice above would delete with the text it replaces. Each such comment line is
+      # kept, moved above the new line at the member's indentation. Only whole comment lines are recognised: RBS
+      # has no string type that spans a line, so a line whose first non-blank character is `#` is a comment.
+      def kept_comments(source, loc)
+        text = source[loc.start_pos...loc.end_pos].to_s
+        return "" unless text.include?("\n")
+
+        indent = source[line_start_index(source, loc.start_pos)...loc.start_pos].to_s
+        indent = "" unless indent.match?(/\A[ \t]*\z/)
+        text.lines.drop(1).filter_map { |line| line.strip if line.match?(/\A\s*#/) }
+            .map { |comment| "#{comment}\n#{indent}" }.join
+      end
+
+      # ADR-112 WD4 — the annotations an inline declaration carries that its `sig/` copy lacks, added above the
+      # member. Additive only: an annotation already there stays, whoever wrote it, so a copy never loses
+      # anything to regeneration (an annotation later deleted inline is therefore not deleted here).
+      def splice_declared_annotations(source, member, candidate)
+        missing = missing_declared_annotations(member, candidate)
+        return source if missing.empty?
+
+        line_start = line_start_index(source, member.location.start_pos)
+        indent = source[line_start...member.location.start_pos].to_s
+        return source unless indent.match?(/\A[ \t]*\z/)
+
+        anchor = annotation_block_start(source, member, line_start)
+        source[0...anchor] + missing.map { |line| "#{indent}#{line}\n" }.join + source[anchor..]
+      end
+
+      # A declared annotation line is `%a` plus a one-character delimiter pair around its content.
+      def missing_declared_annotations(member, candidate)
+        present = member.annotations.map { |annotation| annotation.string.to_s.strip }
+        candidate.declared_annotations.reject { |line| present.include?(line[3...-1].to_s.strip) }
+      end
+
+      # The start of the line the member's first annotation sits on, or of the member's own line.
+      def annotation_block_start(source, member, line_start)
+        starts = member.annotations.filter_map { |annotation| annotation.location&.start_pos }
+        ([line_start] + starts.map { |pos| line_start_index(source, pos) }).min
+      end
+
+      # ADR-103 WD9 — the annotation half of a replacement, and the one place this slice is allowed to
+      # write bytes ABOVE an existing declaration.
+      #
+      # `RBS::Parser` puts a member's annotations OUTSIDE its `location`, so {#apply_replacement} above
+      # already leaves every annotation on the declaration byte-untouched — the `%a{deprecated}` and the
+      # `%a{implicitly-returns-nil}` a user wrote survive an `--overwrite` unchanged. What is left is the
+      # question of adding ours, and the answer is: only onto a declaration that carries none.
+      #
+      # A declaration that already carries an annotation is left exactly as it is, and the candidate is
+      # reported as `sig.effect.left-unreadable`. The writer cannot tell an annotation it authored from
+      # one the user wrote, and it has no grammar for merging two — so rewriting the region could silently
+      # replace an author's own `%a{pure}` with a labelled envelope, or strip a directive Rigor does not
+      # read at all. Leaving it and saying so is the only move that cannot destroy an authored fact.
+      #
+      # An annotation on one of the member's overloads (`def m: %a{pure} (Integer) -> String`) counts too:
+      # it sits inside the location, and a tighter return keeps it (#1436), so ours would be a second one.
+      def splice_annotations(source, member, candidate, state)
+        return source if candidate.annotations.empty?
+
+        if annotated?(member)
+          # Rebuilt so the reported row carries the reason it was actually given. The generator stamped
+          # `:emitted` when it decided the annotation; only the writer knows the declaration refused it.
+          state.left_unreadable << candidate.with_effect_annotation(candidate.annotations, :left_unreadable)
+          return source
+        end
+
+        line_start = line_start_index(source, member.location.start_pos)
+        indent = source[line_start...member.location.start_pos].to_s
+        return source unless indent.match?(/\A[ \t]*\z/)
+
+        source[0...line_start] + candidate.annotations.map { |line| "#{indent}#{line}\n" }.join + source[line_start..]
+      end
+
+      def annotated?(member)
+        return true unless member.annotations.empty?
+
+        member.respond_to?(:overloads) && member.overloads.any? { |overload| overload.annotations.any? }
       end
     end
   end

data/lib/rigor/sig_gen.rb

@@ -1,6 +1,9 @@
 # frozen_string_literal: true
 
+require_relative "sig_gen/alias_index"
 require_relative "sig_gen/classification"
+require_relative "sig_gen/effect_annotation"
+require_relative "sig_gen/inline_declarations"
 require_relative "sig_gen/method_candidate"
 require_relative "sig_gen/observed_call"
 require_relative "sig_gen/meta_class_shape"

data/lib/rigor/signature_path_audit.rb

@@ -32,7 +32,7 @@ module Rigor
     # requiring the loader from here fails outright. `signature_path_audit_spec` pins the two
     # anchors equal, and pins this discovery against `Loader.bundled_plugin_sig_path`, so the
     # duplication cannot drift unnoticed.
-    BUNDLED_PLUGINS_ROOT = File.expand_path("../../plugins", __dir__)
+    BUNDLED_PLUGINS_ROOT = File.expand_path("../../plugins", __dir__).freeze
 
     # One configured `signature_paths:` entry's resolution status.
     #

data/lib/rigor/source/node_walker.rb

@@ -25,7 +25,6 @@ module Rigor
     module NodeWalker
       module_function
 
-      # @return when no block is given.
       def each(root, &)
         return to_enum(__method__, root) unless block_given?
 
@@ -46,8 +45,6 @@ module Rigor
       # itself). The yielded `ancestors` array is the live descent stack — callers that retain it past the
       # block invocation MUST copy it (`Plugin::NodeContext` does). Used by the plugin engine to give
       # `node_rule` blocks their enclosing class / method / block context (ADR-37 slice 1d).
-      #
-      # @return when no block is given.
       def each_with_ancestors(root, &)
         return to_enum(__method__, root) unless block_given?
 

data/lib/rigor/source/parameter_envelope.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require "prism"
+
+module Rigor
+  module Source
+    # Issue #992 — the positional-argument envelope of a `Prism::DefNode`, and the ONE place a `def` nobody
+    # declared is turned into something `call.wrong-arity` can check a call against.
+    #
+    # Both undeclared lanes read it. A method known only to the discovery walk has no other shape, and a
+    # method `rigor-rbs-inline` synthesized a fully defaulted skeleton for (`%a{rigor:v1:inferred-signature}`)
+    # is sent here too rather than having its synthesized member's arity read, so a `def` can never be
+    # judged by two parsers of its parameter list that disagree.
+    #
+    # An envelope is plain frozen data, `[min, max, required_keywords]`, because it rides the ADR-85 seed
+    # bundle through `Marshal`: `max` is nil when a rest or `...` parameter leaves it unbounded, and
+    # `required_keywords` is true when the def takes a required keyword — a call that passes positionals
+    # only then fails on the missing keyword whatever its count, which is a different diagnostic than the
+    # one this envelope backs, so the rule declines on it the way `compute_arity_envelope` declines an RBS
+    # function with required keywords.
+    #
+    # {OPAQUE} is the value every other contribution to a name records — `define_method`, `attr_*`, an alias,
+    # a macro that names the method, a second `def` whose envelope differs — and it absorbs under {.merge}.
+    # That makes the per-name fold a join: order-independent, idempotent, and unable to keep one of several
+    # shapes silently.
+    module ParameterEnvelope
+      module_function
+
+      OPAQUE = :opaque
+
+      # The envelope of `def_node`'s own parameter list. Block, keyword-optional and keyword-rest parameters
+      # never change how many positionals the method accepts; `super`, `yield` and `&block` in the body do
+      # not either, so the body is not read at all.
+      def of(def_node)
+        params = def_node.parameters
+        return [0, 0, false].freeze if params.nil?
+
+        required = params.requireds.size + params.posts.size
+        [required, maximum(params, required), required_keywords?(params)].freeze
+      end
+
+      def maximum(params, required)
+        return nil if params.rest || params.keyword_rest.is_a?(Prism::ForwardingParameterNode)
+
+        required + params.optionals.size
+      end
+
+      def required_keywords?(params)
+        params.keywords.any?(Prism::RequiredKeywordParameterNode)
+      end
+
+      # The join of two contributions to one name: equal envelopes stay, anything else is {OPAQUE}.
+      def merge(left, right)
+        return right if left.nil?
+        return left if right.nil?
+
+        left == right ? left : OPAQUE
+      end
+
+      def opaque?(envelope) = envelope == OPAQUE
+
+      # Folds `overlay`'s per-class entries into `base` with {.merge}, returning a new table. Both are
+      # `{class name => {key => envelope}}`.
+      def merge_tables(base, overlay)
+        return overlay if base.nil? || base.empty?
+        return base if overlay.nil? || overlay.empty?
+
+        base.merge(overlay) { |_class, left, right| left.merge(right) { |_key, a, b| merge(a, b) } }
+      end
+    end
+  end
+end

data/lib/rigor/source.rb

@@ -15,3 +15,4 @@ require_relative "source/node_locator"
 require_relative "source/node_walker"
 require_relative "source/literals"
 require_relative "source/constant_path"
+require_relative "source/parameter_envelope"

data/lib/rigor/type/combinator.rb

@@ -825,24 +825,72 @@ module Rigor
 
           return [top] if flattened.any?(Top)
 
-          absorb_float_ranges(unique_members(flattened))
+          absorb_contained_members(unique_members(flattened))
+        end
+
+        # Drops every member another member already contains, so the join after a guard names one set
+        # instead of several readings of it. The normative relation is
+        # docs/type-specification/normalization.md § "Member absorption"; {absorbed_by?} is that list.
+        #
+        # Only a `FloatRange`, `Tuple` or `HashShape` member can be dropped, so the O(n²) scan is
+        # skipped for every union that carries none of them — this runs on the hot path of every join.
+        #
+        # The `!absorbed_by?(other, member)` re-check costs one predicate call per pair that absorbed
+        # at all, and it is what makes "both arms dropped" unrepresentable should a future clause make
+        # the relation symmetric on a pair of distinct members.
+        def absorb_contained_members(members)
+          return members unless members.any? { |m| absorbable_member?(m) }
+
+          members.reject do |member|
+            absorbable_member?(member) &&
+              members.any? do |other|
+                !other.equal?(member) && absorbed_by?(member, other) && !absorbed_by?(other, member)
+              end
+          end
         end
 
-        # ADR-109 WD5 — a `FloatRange` member is absorbed by a bare `Nominal[Float]` member or by a
-        # `FloatRange` member that contains it. The truthy edge of `x > c` is a range and the falsy
-        # edge keeps `Float`, so the join after every Float guard would otherwise carry both and every
-        # later guard would narrow member by member into a growing union (`Float[...1.0] |
-        # Float[0.0...1.0]`) that names one set. `IntegerRange` keeps its pre-ADR-109 behaviour
-        # (`Integer | Integer[0..5]` stays as written) because both of its edges narrow.
-        def absorb_float_ranges(members)
-          return members unless members.any?(FloatRange)
+        def absorbable_member?(type)
+          type.is_a?(FloatRange) || type.is_a?(Tuple) || type.is_a?(HashShape)
+        end
 
-          members.reject do |member|
-            member.is_a?(FloatRange) &&
-              members.any? { |other| !other.equal?(member) && float_range_absorbed_by?(member, other) }
+        # `narrower`'s inhabitants are a subset of `wider`'s under a rule the union already applies to
+        # a direct member. The structural clauses only lift that same relation element-wise over a
+        # fixed spine; none of them introduces an absorption the flat union does not already perform,
+        # which is why a value-pinned element never collapses (normalization.md keeps `1 | Integer`,
+        # so `[1, String] | [Integer, String]` keeps both arms) and an `IntegerRange` or `Refined`
+        # element never does either.
+        def absorbed_by?(narrower, wider)
+          return true if wider.is_a?(Top) || narrower.is_a?(Bot)
+          return true if listed_in_union?(narrower, wider)
+
+          case narrower
+          when FloatRange then float_range_absorbed_by?(narrower, wider)
+          when Tuple then wider.is_a?(Tuple) && tuple_absorbed_by?(narrower, wider)
+          when HashShape then wider.is_a?(HashShape) && hash_shape_absorbed_by?(narrower, wider)
+          when Union then union_absorbed_by?(narrower, wider)
+          else false
           end
         end
 
+        # Flatten-and-dedupe read one level down: the member is already one of the arms `wider` lists.
+        def listed_in_union?(narrower, wider)
+          wider.is_a?(Union) && wider.members.any? { |member| element_absorbed_or_equal?(narrower, member) }
+        end
+
+        def union_absorbed_by?(narrower, wider)
+          narrower.members.all? { |member| element_absorbed_or_equal?(member, wider) }
+        end
+
+        def element_absorbed_or_equal?(narrower, wider)
+          narrower.equal?(wider) || narrower == wider || absorbed_by?(narrower, wider)
+        end
+
+        # ADR-109 WD5 — a `FloatRange` is absorbed by a bare `Nominal[Float]` or by a `FloatRange` that
+        # contains it. The truthy edge of `x > c` is a range and the falsy edge keeps `Float`, so the
+        # join after every Float guard would otherwise carry both and every later guard would narrow
+        # member by member into a growing union (`Float[...1.0] | Float[0.0...1.0]`) that names one set.
+        # `IntegerRange` keeps its pre-ADR-109 behaviour (`Integer | Integer[0..5]` stays as written)
+        # because both of its edges narrow.
         def float_range_absorbed_by?(range, other)
           case other
           when Nominal then other.class_name == "Float" && other.type_args.empty?
@@ -851,6 +899,34 @@ module Rigor
           end
         end
 
+        # Differing arity is never absorbed: `[A]` and `[A, B]` have disjoint inhabitants, so neither
+        # arm is a reading of the other.
+        def tuple_absorbed_by?(narrower, wider)
+          return false unless narrower.elements.size == wider.elements.size
+
+          narrower.elements.each_with_index.all? do |element, index|
+            element_absorbed_or_equal?(element, wider.elements[index])
+          end
+        end
+
+        def hash_shape_absorbed_by?(narrower, wider)
+          return false unless hash_shape_spine_equal?(narrower, wider)
+
+          narrower.pairs.all? { |key, value| element_absorbed_or_equal?(value, wider.pairs[key]) }
+        end
+
+        # The spine is everything but the value types: the key set and the openness / optionality /
+        # read-only policy. Two shapes that disagree on any of it describe differently-shaped hashes,
+        # and an element-wise reading of their values would not be a containment.
+        def hash_shape_spine_equal?(narrower, wider)
+          narrower.pairs.size == wider.pairs.size &&
+            narrower.extra_keys == wider.extra_keys &&
+            narrower.required_keys == wider.required_keys &&
+            narrower.optional_keys == wider.optional_keys &&
+            narrower.read_only_keys == wider.read_only_keys &&
+            narrower.pairs.each_key.all? { |key| wider.pairs.key?(key) }
+        end
+
         def unique_members(types)
           types.each_with_object([]) do |type, unique|
             unique << type unless unique.any? { |member| member.equal?(type) || member == type }

data/lib/rigor/type/difference.rb

@@ -70,6 +70,7 @@ module Rigor
         "Array" => ->(removed) { removed.is_a?(Tuple) && removed.elements.empty? },
         "Hash" => ->(removed) { removed.is_a?(HashShape) && removed.pairs.empty? }
       }.freeze
+      Ractor.make_shareable(EMPTY_WITNESS_PREDICATES)
       private_constant :EMPTY_WITNESS_PREDICATES
 
       def top

data/lib/rigor/type/hash_shape.rb

@@ -60,7 +60,7 @@ module Rigor
       end
 
       def describe(verbosity = :short)
-        return "{}" if pairs.empty?
+        return "{}" if pairs.empty? && closed?
 
         rendered = pairs.map { |k, v| render_entry(k, v, verbosity) }
         rendered << "..." if open?

data/lib/rigor/type/refined.rb

@@ -176,6 +176,7 @@ module Rigor
         # recovered by inspecting an arbitrary string.
         literal_string: ->(v) { v.is_a?(String) }
       }.freeze
+      Ractor.make_shareable(PREDICATES)
 
       # Maps `[base_class_name, predicate_id]` pairs to their kebab-case canonical name. Registered
       # shapes print through `describe`; unregistered combinations fall back to the operator form.

data/lib/rigor/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Rigor
-  VERSION = "0.3.9"
+  VERSION = "0.4.0"
 end

data/lib/rigor.rb

@@ -10,6 +10,7 @@ require_relative "rigor/environment"
 require_relative "rigor/rbs_extended"
 require_relative "rigor/testing"
 require_relative "rigor/inference/budget_trace"
+require_relative "rigor/inference/external_ancestor_resolution"
 require_relative "rigor/inference/dynamic_origin"
 require_relative "rigor/inference/fallback"
 require_relative "rigor/inference/fallback_tracer"

data/plugins/rigor-actioncable/lib/rigor/plugin/actioncable/effects.rb

@@ -29,6 +29,7 @@ module Rigor
 
         # The `_later` twins enqueue an ActiveJob that broadcasts, so they carry the enqueue meaning too.
         TURBO_LATER_SELECTORS = TURBO_SELECTORS.map { |name| "#{name.delete_suffix('_to')}_later_to" }.freeze
+        Ractor.make_shareable(TURBO_LATER_SELECTORS)
 
         LATER = (BROADCASTING + ["rails.activejob.enqueue", "job.enqueue"]).freeze