rigortype 0.4.6 → 0.4.8

data/lib/rigor/type/combinator.rb

@@ -46,6 +46,27 @@ module Rigor
         @untyped
       end
 
+      # ADR-130 WD2 — the parity predicate. Every site that keys a leniency on `untyped` asks this instead of testing
+      # a `Dynamic`'s facet for `Top` or comparing with {untyped}, so a value whose facet parity erases
+      # ({erased_facet?}) reads as `untyped` everywhere but member dispatch. `spec/rigor/type/untyped_parity_spec.rb`
+      # flags the raw spellings it knows outside this module. True for `Dynamic[top]` and for a plugin-interface
+      # value, `Dynamic[Rigor::Plugin::_Scope]`.
+      def untyped?(type)
+        return false unless type.is_a?(Dynamic)
+
+        facet = type.static_facet
+        facet.is_a?(Top) || erased_facet?(facet)
+      end
+
+      # ADR-130 WD1 — true for a `Dynamic` facet that parity reads as `top`: the `Rigor::Plugin` interface carrier
+      # ({Interface}). {untyped?} answers true for it, and {merge_erased_members} merges it with `Dynamic[top]`.
+      # `spec/rigor/type/combinator_facet_erasure_spec.rb` also drives the merge through a stub facet. An engine
+      # hook, not public API.
+      def erased_facet?(facet)
+        facet.is_a?(Interface)
+      end
+      private_class_method :erased_facet?
+
       # Wraps the static facet in a Dynamic[T] carrier. Idempotent on the static facet so
       # Dynamic[Dynamic[T]] collapses to Dynamic[T] per the value-lattice algebra.
       def dynamic(static_facet)
@@ -245,8 +266,8 @@ module Rigor
       end
 
       # `literal-string` — a `String` that is statically known to come from a source-code literal (or a
-      # composition of literals). v0.0.9 tracks this flow through interpolation `"#{...}"`, leaving
-      # propagation through `+` / `<<` to a later slice. Every `Constant<String>` is implicitly
+      # composition of literals). Interpolation `"#{...}"` and `+` / `*` composition keep
+      # the flow (see {literal_string_compatible?}). Every `Constant<String>` is implicitly
       # literal-string-compatible; the carrier exists for cases where the concrete value is unknown but
       # literal-ness has been established (an RBS::Extended `return: literal-string` annotation, or
       # interpolation over literal-bearing parts).
@@ -433,8 +454,7 @@ module Rigor
       # - `Type::Tuple[A, B, C]` → `Constant<0> | Constant<1> | Constant<2>`.
       # - `Type::Nominal["Hash", [K, V]]` → `K` (untyped if absent).
       # - `Type::Nominal["Array", [E]]` → `non-negative-int`.
-      # - `Type::Constant` whose value is a Hash / Array / Range — project through the literal's
-      #   per-element keys.
+      # - `Type::Constant` wrapping a Range with an Integer begin — `non-negative-int`.
       #
       # Other inputs (`Top`, `Dynamic`, untyped Nominals, `Union`, `Refined`, `Difference`,
       # `Intersection`) project to `top` so the type function always returns a value — callers may narrow
@@ -456,8 +476,7 @@ module Rigor
       # - `Type::Tuple[A, B, C]` → `A | B | C`.
       # - `Type::Nominal["Hash", [K, V]]` → `V` (untyped if absent).
       # - `Type::Nominal["Array", [E]]` → `E` (untyped if absent).
-      # - `Type::Constant` whose value is a Hash / Array / Range — union of `Constant<…>` for each
-      #   element.
+      # - `Type::Constant` wrapping an integer Range — the `IntegerRange` it spans.
       def value_of(type)
         case type
         when HashShape then hash_shape_values(type)
@@ -528,8 +547,7 @@ module Rigor
       # Phase A handles `Type::HashShape` (literal-key K). Phase B (slice 5) extends to `Type::Tuple`
       # (integer-index K) — `pick_of[Tuple[A, B, C], 0 | 2]` evaluates to `Tuple[A, C]`. Non-shape inputs
       # (`Type::Nominal`, etc.) return `type` unchanged ("lossy degradation"; the
-      # `dynamic.shape.lossy-projection` diagnostic that flags the boundary lands when caller-side
-      # diagnostic threading arrives).
+      # `dynamic.shape.lossy-projection` diagnostic that flags the boundary).
       def pick_of(type, keys)
         case type
         when HashShape then hash_shape_pick(type, keys)
@@ -597,8 +615,7 @@ module Rigor
       # site where the projection was authored.
       #
       # `HashShape` and `Tuple` carry shape-level information the projections honour; every other carrier
-      # is lossy. Slice 5b wires diagnostic emission through `RbsExtended` / parser callers; this
-      # predicate stands alone in slice 5 for unit-test coverage and future composition.
+      # is lossy.
       def shape_projection_lossy?(type)
         !type.is_a?(HashShape) && !type.is_a?(Tuple)
       end
@@ -792,9 +809,9 @@ module Rigor
           top
         end
 
-        # `Type::Constant` only carries scalar literals (Integer / Float / String / Symbol / Range /
-        # Rational / Complex / true / false / nil); Array and Hash literals become Tuple / HashShape
-        # carriers earlier in the typer. Range is the only scalar with meaningful key/value projections.
+        # `Type::Constant` only carries scalar literals (`Constant::SCALAR_CLASSES`); Array and Hash literals
+        # become Tuple / HashShape carriers earlier in the typer. Range is the only scalar with meaningful
+        # key/value projections.
         def constant_keys(value)
           return non_negative_int if value.is_a?(Range) && value.begin.is_a?(Integer)
 
@@ -825,7 +842,104 @@ module Rigor
 
           return [top] if flattened.any?(Top)
 
-          absorb_contained_members(unique_members(flattened))
+          absorb_contained_members(merge_erased_members(unique_members(flattened)))
+        end
+
+        # ADR-130 WD1 — a facet parity erases ({erased_facet?}) must not give a join a shape master's dedup would
+        # not: `Dynamic[_A] | Dynamic[top]` is `Dynamic[top]`, and so are the same members anywhere inside a carrier
+        # that holds a type ({TYPE_CHILDREN}). Members equal after {erase_facets} merge into the erased form, at the
+        # first one's position; a member no other matches keeps its facet, and {absorb_contained_members} compares
+        # the erased forms too. The facet scan runs on every join and allocates nothing (no enumerator, no array),
+        # so the merge costs only where a facet is present, which is nowhere until ADR-130 slice 1b.
+        def merge_erased_members(members)
+          return members if members.size < 2
+          return members unless members.any? { |member| facet_bearing?(member) }
+
+          erased = members.map { |member| erase_facets(member) }
+          counts = Hash.new(0)
+          erased.each { |type| counts[type] += 1 }
+          merged = {}
+          result = []
+          members.each_with_index do |member, index|
+            type = erased[index]
+            if counts[type] == 1
+              result << member
+            elsif !merged.key?(type)
+              merged[type] = true
+              result << type
+            end
+          end
+          result
+        end
+
+        def facet_bearing?(type)
+          return erased_facet?(type.static_facet) || facet_bearing?(type.static_facet) if type.is_a?(Dynamic)
+
+          readers = TYPE_CHILDREN[type.class]
+          return false if readers.nil?
+
+          readers.each { |reader| return true if child_facet_bearing?(type.public_send(reader)) }
+          false
+        end
+
+        def child_facet_bearing?(child)
+          case child
+          when Array then child.any? { |type| facet_bearing?(type) }
+          when Hash
+            child.each_value { |type| return true if facet_bearing?(type) }
+            false
+          else facet_bearing?(child)
+          end
+        end
+
+        # `type` with every facet {erased_facet?} accepts rewritten to `top`, through every carrier
+        # {TYPE_CHILDREN} lists. The identity, by reference, on a type that bears none. A facet-bearing `Dynamic`
+        # is never `Dynamic[top]`, so {untyped?} answers the hook for it here.
+        def erase_facets(type)
+          return type unless facet_bearing?(type)
+
+          case type
+          when Dynamic then untyped?(type) ? untyped : dynamic(erase_facets(type.static_facet))
+          when Union then union(*erase_each(type.members))
+          when Intersection then intersection(*erase_each(type.members))
+          when Tuple then tuple_of(*erase_each(type.elements))
+          when Nominal then nominal_of(type.class_name, type_args: erase_each(type.type_args))
+          when HashShape then erase_shape_facets(type)
+          else erase_wrapper_facets(type)
+          end
+        end
+
+        def erase_wrapper_facets(type)
+          case type
+          when Difference then Difference.new(erase_facets(type.base), erase_facets(type.removed))
+          when Refined then Refined.new(erase_facets(type.base), type.predicate_id)
+          when Maybe then Maybe.new(erase_facets(type.value_type))
+          when Result then Result.new(erase_facets(type.ok_type), erase_facets(type.err_type))
+          else erase_bearer_facets(type)
+          end
+        end
+
+        def erase_bearer_facets(type)
+          case type
+          when App then App.new(type.uri, erase_each(type.args), bound: erase_facets(type.bound))
+          when BoundMethod
+            BoundMethod.new(receiver_type: erase_facets(type.receiver_type), method_name: type.method_name)
+          when DataInstance then DataInstance.new(erase_values(type.members), type.class_name)
+          when StructInstance then StructInstance.new(erase_values(type.members), type.class_name)
+          # The facet itself, erased apart from its `Dynamic` (which erases whole, to `untyped`).
+          when Interface then Interface.new(type.name, erase_each(type.type_args))
+          else type
+          end
+        end
+
+        def erase_each(types) = types.map { |type| erase_facets(type) }
+
+        def erase_values(pairs) = pairs.transform_values { |type| erase_facets(type) }
+
+        def erase_shape_facets(shape)
+          HashShape.new(erase_values(shape.pairs),
+                        required_keys: shape.required_keys, optional_keys: shape.optional_keys,
+                        read_only_keys: shape.read_only_keys, extra_keys: shape.extra_keys)
         end
 
         # Drops every member another member already contains, so the join after a guard names one set
@@ -839,15 +953,30 @@ module Rigor
         # 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.
+        #
+        # ADR-130 WD1 — the relation reads each member's erased form ({erase_facets}), so a facet does not keep an
+        # arm master absorbs: `[Dynamic[_A]] | [Dynamic[top] | Integer]` drops the first arm as master's
+        # `[Dynamic[top]] | [Dynamic[top] | Integer]` does. Without a facet the readings are the members themselves.
         def absorb_contained_members(members)
           return members unless members.any? { |m| absorbable_member?(m) }
 
           members = join_sequence_elements(members)
-          members.reject do |member|
-            absorbable_member?(member) &&
-              members.any? do |other|
-                !other.equal?(member) && absorbed_by?(member, other) && !absorbed_by?(other, member)
-              end
+          readings = members.any? { |member| facet_bearing?(member) } ? members.map { |m| erase_facets(m) } : members
+          # `each_index`, not `each_with_index`: the Enumerable form allocates an iterator object on every join.
+          kept = []
+          members.each_index do |index|
+            member = members[index]
+            kept << member unless absorbable_member?(member) && absorbed_reading?(readings, index)
+          end
+          kept
+        end
+
+        # `any?` rather than an early `return` from an `each` block: a non-local return allocates on every absorbed
+        # member. Readings are distinct objects (the members were made unique, and an erased form is a new object).
+        def absorbed_reading?(readings, index)
+          reading = readings[index]
+          readings.any? do |wider|
+            !wider.equal?(reading) && absorbed_by?(reading, wider) && !absorbed_by?(wider, reading)
           end
         end
 
@@ -1044,10 +1173,18 @@ module Rigor
         # need not render alike (`Constant[1..2]` and `Constant[1..2.0]`), so equality is not a safe key. A
         # non-main Ractor may not read the module's ivar, so a pool worker renders the key every time, as every
         # run did before.
+        #
+        # ADR-130 WD1 — a member bearing a facet sorts by its erased form's rendering, so a facet does not move it:
+        # `Dynamic[_A] | Dynamic[String]` keeps master's `Dynamic[String] | Dynamic[top]` order. The facet scan runs
+        # only when a key is rendered, and a member without a facet renders as it always did.
         def sort_key(member)
-          return member.describe(:short) unless Ractor.main?
+          return render_sort_key(member) unless Ractor.main?
 
-          @sort_keys[member] ||= member.describe(:short)
+          @sort_keys[member] ||= render_sort_key(member)
+        end
+
+        def render_sort_key(member)
+          (facet_bearing?(member) ? erase_facets(member) : member).describe(:short)
         end
       end
 
@@ -1056,6 +1193,21 @@ module Rigor
       # The main Ractor's {sort_key} memo, allocated here for the same reason.
       @sort_keys = ObjectSpace::WeakMap.new
 
+      # ADR-130 WD1 — the readers of every type a carrier holds, which facet erasure walks. A leaf lists none.
+      # `spec/rigor/type/combinator_facet_erasure_spec.rb` fails on a `Rigor::Type` carrier missing here, and on a
+      # listed carrier whose erasure leaves a facet in any of its type slots.
+      TYPE_CHILDREN = Ractor.make_shareable(
+        {
+          Top => [], Bot => [], Constant => [], IntegerRange => [], FloatRange => [], Singleton => [],
+          DataClass => [], StructClass => [],
+          Dynamic => %i[static_facet], Nominal => %i[type_args], Tuple => %i[elements], HashShape => %i[pairs],
+          Union => %i[members], Intersection => %i[members], Difference => %i[base removed], Refined => %i[base],
+          Maybe => %i[value_type], Result => %i[ok_type err_type], App => %i[args bound],
+          BoundMethod => %i[receiver_type], DataInstance => %i[members], StructInstance => %i[members],
+          Interface => %i[type_args]
+        }
+      )
+
       NIL_CONSTANT = Constant.new(nil)
       TRUE_CONSTANT = Constant.new(true)
       FALSE_CONSTANT = Constant.new(false)

data/lib/rigor/type/constant.rb

@@ -8,9 +8,8 @@ require_relative "plain_lattice"
 module Rigor
   module Type
     # A literal carrier under ADR-3 OQ1 Option C (Hybrid). Wraps a Ruby literal value of one of the
-    # supported immutable-ish classes. Compound literal shapes (Tuple, HashShape, Record) get dedicated
-    # classes in later slices; Range is carried only when both static endpoints are known enough for
-    # tuple slicing.
+    # supported immutable-ish classes. Compound literal shapes (Tuple, HashShape) have their own classes;
+    # Range is carried only when both static endpoints are known enough for tuple slicing.
     #
     # See docs/adr/4-type-inference-engine.md for the tentative answer to the open question and
     # docs/type-specification/rigor-extensions.md for the refinement neighbourhood this carrier lives in.
@@ -74,12 +73,12 @@ module Rigor
 
       # RBS supports `Literal` types for booleans, nil, integer literals (positive and negative), symbol
       # literals, and string literals. Erasing to these preserves the carrier's precision at the RBS
-      # boundary — `Constant<64>` round-trips as `64`, not as `Integer` — and
+      # boundary — the constant 64 round-trips as `64`, not as `Integer` — and
       # `RbsTypeTranslator#translate_literal` already maps the parsed RBS Literal back to `Constant`.
       # Scalar carriers without RBS Literal support (Float, Range, Rational, Complex, Regexp, Pathname)
       # keep their pre-existing widen-to-class-name behaviour because RBS rejects their literal spellings
       # as syntax errors. `Range` is generic (`Range[out E]`), and a bare `Range` fails `rbs validate`, so
-      # it carries the class of its endpoints, or `untyped` when both are nil (#1891). `Set[unchecked out A]` is
+      # it carries the class of its endpoints, or `untyped` when both are nil (#1891). `Set` is
       # generic too, and a set is mutable: the constant's elements are only what it held when it was built, and
       # `x << "a"` adds a member they do not name. It erases to `Set[untyped]`, as an Array or Hash literal's
       # element type is widened rather than pinned (#2177).

data/lib/rigor/type/hash_shape.rb

@@ -28,14 +28,14 @@ module Rigor
       ALLOWED_KEY_CLASSES = [Symbol, String, Integer, Float, TrueClass, FalseClass, NilClass].freeze
       EXTRA_KEY_POLICIES = %i[open closed].freeze
       POLICY_KEYWORDS = %i[required_keys optional_keys read_only_keys extra_keys].freeze
-      # A Symbol whose text matches renders as a bare RBS record key (`lang:`) in {#erase_to_rbs};
-      # anything else is a quoted Symbol with a fat arrow (`:"data-contrast" =>`). See {#erase_key_prefix}.
+      # A Symbol whose text matches renders as a bare RBS record key (`lang:`) in {#describe} and {#erase_to_rbs};
+      # anything else is a quoted Symbol with a fat arrow (`:"data-contrast" =>`). See {#key_prefix}.
       BARE_RECORD_KEY = /\A[A-Za-z_][A-Za-z0-9_]*[?!]?\z/
 
       attr_reader :pairs, :required_keys, :optional_keys, :read_only_keys, :extra_keys
 
       # @param pairs — ordered map of
-      #   keys to declared types. Keys MUST be Symbol or String;
+      #   keys to declared types. Keys MUST be one of ALLOWED_KEY_CLASSES;
       #   values MUST be Rigor::Type instances. The hash is duped and
       #   frozen at construction; callers MUST NOT mutate the input
       #   afterwards (mutation does not affect the carrier, but the
@@ -74,7 +74,7 @@ module Rigor
         return hash_erasure unless closed?
         return hash_erasure if pairs.each_key.any? { |k| !k.is_a?(Symbol) || !record_key_spellable?(k) }
 
-        rendered = pairs.map { |k, v| "#{erase_key_prefix(k)} #{v.erase_to_rbs}" }
+        rendered = pairs.map { |k, v| "#{key_prefix(k)} #{v.erase_to_rbs}" }
         "{ #{rendered.join(', ')} }"
       end
 
@@ -193,46 +193,27 @@ module Rigor
       def render_entry(key, value, verbosity)
         prefix = []
         prefix << "readonly" if read_only_key?(key)
-        rendered_key = optional_key?(key) ? "?#{render_key(key)}" : render_key(key)
-        prefix << "#{rendered_key}#{key_separator(key)}"
+        prefix << key_prefix(key)
         "#{prefix.join(' ')} #{value.describe(verbosity)}"
       end
 
-      # `describe` is a human-facing display contract (it feeds diagnostic messages, never a parser),
-      # so it keeps the compact `"a":` form for a quoted key. Non-(Symbol|String) scalar keys render in
-      # the natural hashrocket spelling (`1 => 2`, `1.0 => 4`, `nil => 0`) via {#key_separator}; their
-      # `inspect` is the canonical Ruby literal, so describe stays deterministic. The RBS-erasure path
-      # uses {#erase_key_prefix} instead, which must emit a parseable key.
-      def render_key(key)
-        case key
-        when Symbol then key.to_s
-        else key.inspect
-        end
-      end
-
-      # Symbol / String keys keep the compact colon form (`a: 1`, `"k": 2`); every other scalar key uses
-      # the hashrocket (`1 => 2`) — the form the user would have to write in source.
-      def key_separator(key)
-        case key
-        when Symbol, String then ":"
-        else " =>"
-        end
-      end
-
-      # An RBS record entry's key + separator, for the {#erase_to_rbs} path (which only ever sees
-      # Symbol keys — string-keyed shapes degrade to `Hash[...]` before reaching here). A Symbol whose
-      # text is a plain identifier is a bare key with a colon (`lang:`, Ruby keywords like `class`
-      # included). Any other Symbol is a quoted Symbol literal with a fat arrow (`:"data-contrast" =>`):
-      # RBS rejects a bare non-identifier (`data-contrast:`) and a quoted key with a colon
-      # (`"data-contrast":`), and reads `"data-contrast" =>` as the String key, so the written record
-      # declared a key the body never has (#2176). Optional keys carry a leading `?`.
-      def erase_key_prefix(key)
+      # A key and its separator as RBS spells them, with a leading `?` for an optional key. `describe`
+      # (the diagnostic display) and {#erase_to_rbs} (which only ever sees Symbol keys — string-keyed
+      # shapes degrade to `Hash[...]` before reaching here) share it, so a key reads the same in a
+      # message as in the signature it erases to. A Symbol whose text is a plain identifier is a bare
+      # key with a colon (`lang:`, Ruby keywords like `class` included). Any other Symbol is a quoted
+      # Symbol literal with a fat arrow (`:"data-contrast" =>`): RBS rejects a bare non-identifier
+      # (`data-contrast:`) and a quoted key with a colon (`"data-contrast":`), and reads
+      # `"data-contrast" =>` as the String key, so the written record declared a key the body never has
+      # (#2176). Every other key, a String included, is its `inspect` literal with a fat arrow
+      # (`"a-b" =>`, `1 =>`, `nil =>`): the compact `"a-b":` would read as a Symbol key in Ruby, so a
+      # String-vs-Symbol key mismatch in a diagnostic was unreadable (#2235).
+      def key_prefix(key)
         optional = optional_key?(key) ? "?" : ""
-        if BARE_RECORD_KEY.match?(key.to_s)
-          "#{optional}#{key}:"
-        else
-          "#{optional}:#{key.to_s.inspect} =>"
-        end
+        return "#{optional}#{key.inspect} =>" unless key.is_a?(Symbol)
+        return "#{optional}#{key}:" if BARE_RECORD_KEY.match?(key.to_s)
+
+        "#{optional}:#{key.to_s.inspect} =>"
       end
 
       # `String#inspect` escapes `#{`, `#$` and `#@` as `\#`, which RBS's parser does not read back as

data/lib/rigor/type/interface.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require_relative "../trinary"
+require_relative "../value_semantics"
+require_relative "acceptance_router"
+require_relative "plain_lattice"
+
+module Rigor
+  module Type
+    # ADR-130 WD1 — an RBS interface under `Rigor::Plugin` (`_Scope`, `_Environment`, ...), as the facet of the
+    # `Dynamic` that carries a plugin-interface value: `Dynamic[Rigor::Plugin::_Scope]`. It appears only there.
+    # `Combinator.untyped?` reads such a `Dynamic` as `untyped`, and union normalisation erases it to `Dynamic[top]`
+    # wherever a join would otherwise keep an arm master does not, so the facet changes one behaviour: a call of a
+    # member the interface declares resolves through that member's RBS (`RbsDispatch`, ADR-130 WD3).
+    #
+    # `name` is spelled as `Nominal#class_name` is (`Rigor::Plugin::_Scope`), and `type_args` are the interface's
+    # type arguments, translated in the caller's context. Every other RBS interface still translates to
+    # `Dynamic[top]` (`RbsTypeTranslator`, ADR-130 WD4).
+    class Interface
+      attr_reader :name, :type_args
+
+      EMPTY_TYPE_ARGS = [].freeze
+      private_constant :EMPTY_TYPE_ARGS
+
+      def initialize(name, type_args = EMPTY_TYPE_ARGS)
+        raise ArgumentError, "name must be a String, got #{name.class}" unless name.is_a?(String)
+
+        @name = name.frozen? ? name : name.dup.freeze
+        @type_args = type_args.frozen? ? type_args : type_args.dup.freeze
+        freeze
+      end
+
+      def describe(verbosity = :short)
+        return name if type_args.empty?
+
+        "#{name}[#{type_args.map { |arg| arg.describe(verbosity) }.join(', ')}]"
+      end
+
+      # A facet never reaches erasure on its own (`Dynamic#erase_to_rbs` is `untyped`); spelled as RBS for a
+      # caller that erases the carrier directly.
+      def erase_to_rbs
+        return name if type_args.empty?
+
+        "#{name}[#{type_args.map(&:erase_to_rbs).join(', ')}]"
+      end
+
+      include Rigor::Type::PlainLattice
+
+      include Rigor::Type::AcceptanceRouter
+
+      include Rigor::ValueSemantics
+
+      value_fields :name, :type_args
+
+      def inspect
+        "#<Rigor::Type::Interface #{describe(:short)}>"
+      end
+    end
+  end
+end

data/lib/rigor/type/union.rb

@@ -49,7 +49,7 @@ module Rigor
         end
       end
 
-      # ADR-1 § "RBS round-trip is lossless" + the value-lattice rule `untyped | T = untyped` (every `T`
+      # ADR-1 § "Erasure Must Be Conservative" + the value-lattice rule `untyped | T = untyped` (every `T`
       # is gradually consistent with `untyped`). When any union member erases to `"untyped"`, the whole
       # union erases to `"untyped"` — the RBS surface has no carrier for "Dynamic-origin alongside a
       # static facet", and the gradual-consistency contract guarantees the substitution is sound at every

data/lib/rigor/type.rb

@@ -28,6 +28,7 @@ require_relative "type/union"
 require_relative "type/difference"
 require_relative "type/refined"
 require_relative "type/intersection"
+require_relative "type/interface"
 require_relative "type/app"
 require_relative "type/result"
 require_relative "type/maybe"

data/lib/rigor/type_node/identifier.rb

@@ -22,8 +22,7 @@ module Rigor
         # Freeze the String field so the resulting Data object is `Ractor.shareable?` regardless of
         # whether the caller passed a `# frozen_string_literal: true` constant or a dynamically built
         # String. The same discipline applies to every other TypeNode value object — they live in the
-        # parser's hot path and are the natural carriers to flow through future Ractor boundaries
-        # (see CURRENT_WORK Open Items #8).
+        # parser's hot path and are the natural carriers to flow through future Ractor boundaries.
         super(name: name.frozen? ? name : name.dup.freeze)
       end
     end

data/lib/rigor/type_node/resolver_chain.rb

@@ -16,7 +16,7 @@ module Rigor
     # resolver in the chain plus the built-in registry through the
     # same entry point.
     #
-    # Constructed once per `Analysis::Runner.run` from
+    # Built by `Environment#build_name_scope` from
     # `Plugin::Registry#type_node_resolvers`. The chain is
     # immutable and re-entrant; the parser may consult it many
     # times for the same node.

data/lib/rigor/type_node/string_literal.rb

@@ -7,8 +7,7 @@ module Rigor
     # `Pick[T, "name"]`, `pick_of[Shape, "a" | "b"]`, and downstream
     # plugin resolvers that accept literal key selectors.
     #
-    # ADR-13 follow-up (`docs/CURRENT_WORK.md` engineering item
-    # #2): the RBS::Extended grammar previously could not tokenise
+    # ADR-13 follow-up: the RBS::Extended grammar previously could not tokenise
     # `"name"` inside a type-arg position. The resolver translates
     # this node to a `Type::Constant` carrying the string value.
     # Slice 1 supports double-quoted strings without escape

data/lib/rigor/type_node/symbol_literal.rb

@@ -7,8 +7,7 @@ module Rigor
     # `Pick[T, :name]`, `pick_of[Shape, :a | :b]`, and downstream
     # plugin resolvers that accept literal key selectors.
     #
-    # ADR-13 follow-up (`docs/CURRENT_WORK.md` engineering item
-    # #2): the RBS::Extended grammar previously could not tokenise
+    # ADR-13 follow-up: the RBS::Extended grammar previously could not tokenise
     # `:name` inside a type-arg position; this addition closes the
     # gap so `ImportedRefinements.parse` produces a uniform AST.
     # The resolver translates this node to a `Type::Constant`

data/lib/rigor/type_node/union.rb

@@ -5,8 +5,7 @@ module Rigor
     # Union AST node. Carries the nodes of a `T1 | T2 | …` union
     # expression authored at type-arg position.
     #
-    # ADR-13 follow-up (`docs/CURRENT_WORK.md` engineering item
-    # #2): together with {SymbolLiteral} / {StringLiteral} this
+    # ADR-13 follow-up: together with {SymbolLiteral} / {StringLiteral} this
     # closes the parser-side gap that prevented `Pick[T, :a | :b]`
     # / `Pick[T, "a" | "b"]` from tokenising. The resolver pass
     # recurses through each node and folds them via
@@ -16,10 +15,8 @@ module Rigor
     # shadowing `Data#members`, which is the introspection method
     # every `Data.define` mix-in inherits.
     #
-    # Nodes are themselves any of the {TypeNode} carriers — the
-    # parser builds a flat list (left-associative); nested
-    # `Union` nodes are permitted but the parser does not
-    # synthesise them by itself.
+    # The parser builds a flat list (left-associative); the constructor
+    # rejects a nested `Union` node.
     class Union < Data.define(:nodes)
       def initialize(nodes:)
         unless nodes.is_a?(Array) && nodes.size >= 2 && nodes.all? { |m| valid_member?(m) }

data/lib/rigor/type_of_memo/serving.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module Rigor
+  module TypeOfMemo
+    # G1's stage-4 form (ADR-129 WD5), mixed into {TypeOfMemo}'s singleton: on a would-be hit with
+    # `TypeOfMemo.enable!(serve: true)`, the memo serves the entry and checks it against a recomputation. For specs
+    # and audit tools; the CLI's `RIGOR_TYPE_OF_SHADOW=1` never serves.
+    module Serving
+      EMPTY = [].freeze
+      private_constant :EMPTY
+
+      private
+
+      # G1's stage-4 form (ADR-129 WD5) on one would-be hit:
+      # 1. recompute on the same scope objects with the memo suspended, in a capture and a priors window, and record
+      #    the final state of every entry either side touches; a recomputation that touched a Resource is a mismatch
+      #    and its answer stands;
+      # 2. undo the recomputation's Table writes and drop its journal records, which the served entry replaces;
+      # 3. serve the entry: validate its reads, merge them into the enclosing captures, replay its writes, and compare
+      #    the touched entries and the type with the recorded ones. A recomputation that raises where an entry exists
+      #    is a mismatch too.
+      def serve_hit(state, table, phase, scope, node, entry, &)
+        stored, reads, writes = entry.is_a?(Array) ? entry : [entry, EMPTY, EMPTY]
+        count(phase, :checked)
+        mark = state.journal_size
+        fresh, priors, refused = recompute(state, table, phase, scope, node, stored, &)
+        if refused
+          judge(state, phase, scope, node, stored, fresh, writes, priors, refused)
+          return fresh
+        end
+
+        serve(state, phase, scope, node, stored, fresh, [reads, writes, priors, mark])
+      end
+
+      # Steps 2 and 3 of {#serve_hit}. An error in them (a replay into a store the entry outlived) is a mismatch,
+      # counted rather than raised into the typing path's rescues. The recomputation's type is answered; the tables may
+      # hold a partial replay by then, which the counted mismatch already fails.
+      def serve(state, phase, scope, node, stored, fresh, slices)
+        reads, writes, priors, mark = slices
+        live = touched(writes, priors).map { |slot, key| [slot, key, state.entry(slot, key)] }
+        state.undo(priors)
+        state.truncate_journal(mark)
+        kinds = []
+        kinds << :revalidate if state.stale_read(reads)
+        state.merge_reads(reads)
+        state.replay(writes)
+        served(state, phase, scope, node, kinds, stored, fresh, live)
+        stored
+      rescue StandardError => e
+        report(phase, scope, node, [:serve_error, "#{e.class}: #{e.message[0, 120]}"], stored, fresh, [])
+        fresh
+      end
+
+      def recompute(state, table, phase, scope, node, stored)
+        state.open_capture
+        state.open_priors
+        table.suspended += 1
+        returned = false
+        begin
+          fresh = yield
+          returned = true
+        ensure
+          table.suspended -= 1
+          priors = state.close_priors
+          refused, = state.close_capture
+          report(phase, scope, node, [:raised], stored, nil, []) unless returned
+        end
+        [fresh, priors, refused]
+      end
+
+      # Every entry the served writes or the recomputation's writes touch, each once.
+      def touched(writes, priors)
+        seen = TypingState::KeyIndex.new
+        keys = []
+        [writes, priors].each do |slice|
+          slice.each_slice(3) do |slot, key, _|
+            next if seen.key?(slot, key)
+
+            seen.store(slot, key, true)
+            keys << [slot, key]
+          end
+        end
+        keys
+      end
+
+      def served(state, phase, scope, node, kinds, stored, fresh, live) # rubocop:disable Metrics/ParameterLists
+        kinds << :type unless same?(fresh, stored)
+        diffs = live.filter_map do |slot, key, want|
+          now = state.entry(slot, key)
+          [slot, key, want, now] unless same?(want, now)
+        end
+        kinds << :table unless diffs.empty?
+        report(phase, scope, node, kinds, stored, fresh, diffs) unless kinds.empty?
+      rescue StandardError => e
+        report(phase, scope, node, [:judge_error, "#{e.class}: #{e.message[0, 120]}"], stored, fresh, [])
+      end
+    end
+  end
+end