rigortype 0.1.19 → 0.2.1

data/lib/rigor/inference/acceptance.rb

@@ -249,6 +249,12 @@ module Rigor
             # anonymous local-bound form projects to `Data` itself).
             accepts(self_type, project_data_instance_to_nominal(other_type), mode: mode)
               .with_reason("projected DataInstance to Nominal[#{other_type.class_name || 'Data'}]")
+          when Type::StructInstance
+            # ADR-48 Struct follow-up: same projection as DataInstance — a
+            # class-tagged Struct value is exactly one value of its tagging
+            # class (the anonymous form projects to `Struct` itself).
+            accepts(self_type, project_struct_instance_to_nominal(other_type), mode: mode)
+              .with_reason("projected StructInstance to Nominal[#{other_type.class_name || 'Struct'}]")
           when Type::Difference, Type::Refined
             # A refinement carrier's value set is a subset of its
             # base. So if `self` (Nominal) accepts the base, it
@@ -386,6 +392,10 @@ module Rigor
           Type::Combinator.nominal_of(instance.class_name || "Data")
         end
 
+        def project_struct_instance_to_nominal(instance)
+          Type::Combinator.nominal_of(instance.class_name || "Struct")
+        end
+
         def project_hash_shape_to_nominal(shape)
           return Type::Combinator.nominal_of(Hash) if shape.pairs.empty?
 
@@ -822,15 +832,13 @@ module Rigor
           Type::AcceptsResult.no(mode: mode, reasons: reason)
         end
 
-        # Slice 4 phase 2c uses Ruby's actual class hierarchy to answer
-        # "is D a subclass of C?". This works for any class loadable
-        # through Object.const_get -- core, stdlib, and live application
-        # classes. When either name fails to resolve we surface "maybe":
-        # the caller (overload selector) treats yes/maybe identically,
-        # so the conservative answer keeps overload coverage intact.
-        # Slice 5 will replace this with an RBS-driven hierarchy lookup
-        # so ahead-of-time type checking no longer relies on Ruby
-        # loading the application classes.
+        # Uses Ruby's actual class hierarchy via Object.const_get to answer
+        # "is D a subclass of C?" for core, stdlib, and application classes.
+        # When either name fails to resolve we surface "maybe": the caller
+        # (overload selector) treats yes/maybe identically, so the conservative
+        # answer keeps overload coverage intact. RbsHierarchy exists but this
+        # path does not yet consult it; migration to an RBS-driven lookup
+        # is deferred.
         def class_subtype_result(target_name:, actual_name:, mode:, kind:)
           return Type::AcceptsResult.yes(mode: mode, reasons: "exact name match") if target_name == actual_name
 

data/lib/rigor/inference/block_parameter_binder.rb

@@ -183,9 +183,8 @@ module Rigor
       # `|*rest|` binds an Array of the leftover positional arguments.
       # The expected-types array is per-position, not per-rest; we
       # cannot reliably pick a single element type for rest, so we
-      # default to `Array[Dynamic[Top]]`. Slice C sub-phase 2 may
-      # tighten this when the receiving method's RBS rest type is
-      # available.
+      # default to `Array[Dynamic[Top]]`. Element-type precision for
+      # rest parameters is deferred (demand-gated).
       def bind_rest(params_node, bindings)
         rest = params_node.rest
         return unless rest.respond_to?(:name) && rest&.name

data/lib/rigor/inference/builtins/comparable_catalog.rb

@@ -11,8 +11,8 @@ module Rigor
       # catalog is NOT routed through
       # `MethodDispatcher::ConstantFolding::CATALOG_BY_CLASS`
       # (which dispatches on the receiver's concrete class).
-      # The data is consumed by future include-aware lookup —
-      # see `docs/CURRENT_WORK.md` for the planned slice.
+      # The data is wired into `MODULE_CATALOGS` in
+      # `MethodDispatcher::ConstantFolding` (ancestor-chain lookup).
       COMPARABLE_CATALOG = MethodCatalog.for_topic(
         "comparable",
         mutating_selectors: {

data/lib/rigor/inference/builtins/enumerable_catalog.rb

@@ -11,8 +11,8 @@ module Rigor
       # catalog is NOT routed through
       # `MethodDispatcher::ConstantFolding::CATALOG_BY_CLASS`
       # (which dispatches on the receiver's concrete class).
-      # The data is consumed by future include-aware lookup —
-      # see `docs/CURRENT_WORK.md` for the planned slice.
+      # The data is wired into `MODULE_CATALOGS` in
+      # `MethodDispatcher::ConstantFolding` (ancestor-chain lookup).
       ENUMERABLE_CATALOG = MethodCatalog.for_topic(
         "enumerable",
         mutating_selectors: {

data/lib/rigor/inference/builtins/method_catalog.rb

@@ -27,6 +27,24 @@ module Rigor
         FOLDABLE_PURITIES = Set["leaf", "trivial", "leaf_when_numeric"].freeze
         EMPTY_CATALOG = { "classes" => {} }.freeze
 
+        # Selectors that are classified `:leaf` by the C-body analysis
+        # (they read no global mutable state in the C sense) but whose
+        # result is NOT reproducible across Ruby processes, so they must
+        # never be folded into a `Constant`:
+        #
+        # - `hash` — every core `#hash` (`String`/`Symbol`/`Integer`/
+        #   `Float`/…) is salted with a per-process SipHash seed, so
+        #   `"x".hash` differs in every process. Folding bakes one
+        #   process's value into the type and the on-disk cache.
+        # - `object_id` / `__id__` — identity-allocated per process.
+        #
+        # This is a UNIVERSAL block (across every catalogued class)
+        # because `hash` / `object_id` are `Object`-level and present on
+        # every receiver; a per-class blocklist would silently miss a
+        # class. The deterministic siblings (`inspect`, `to_s`) are
+        # unaffected.
+        NON_REPRODUCIBLE_SELECTORS = Set[:hash, :object_id, :__id__].freeze
+
         # Shared root for the offline-generated catalogues. Resolving it
         # here keeps the repo-relative `../../../../` hop in one place
         # instead of copying it into every per-topic loader.
@@ -59,6 +77,7 @@ module Rigor
 
         def safe_for_folding?(class_name, selector, kind: :instance)
           class_name_str = class_name.to_s
+          return false if NON_REPRODUCIBLE_SELECTORS.include?(selector.to_sym)
           return false if blocked?(class_name_str, selector)
 
           entry = method_entry(class_name_str, selector, kind: kind)

data/lib/rigor/inference/builtins/string_catalog.rb

@@ -22,7 +22,15 @@ module Rigor
             :replace, :initialize, :initialize_copy, :clear, :<<, :concat, :insert,
             :prepend, :force_encoding, :encode, :scrub, :unicode_normalize, :"[]=",
             :upto, :each_byte, :each_char, :each_codepoint,
-            :each_grapheme_cluster, :each_line, :bytesplice
+            :each_grapheme_cluster, :each_line, :bytesplice,
+            # `crypt` is not a mutator but is blocked from folding for the
+            # same "do not bake a non-pure result into a Constant" reason:
+            # `rb_str_crypt` delegates to the platform `crypt(3)`, whose
+            # output (algorithm and digest) varies by libc / OS, so
+            # `"x".crypt("ab")` is not deterministic across the platforms
+            # an analyzed project may target. The catalog classifies it
+            # `:leaf` from its C body; this entry overrides that.
+            :crypt
           ],
           "Symbol" => Set[
             # Symbol is immutable in Ruby; the classifier mis-flags

data/lib/rigor/inference/expression_typer.rb

@@ -4,6 +4,7 @@ require "prism"
 
 require_relative "../type"
 require_relative "../ast"
+require_relative "../source/constant_path"
 require_relative "../analysis/self_call_resolution_recorder"
 require_relative "block_parameter_binder"
 require_relative "body_fixpoint"
@@ -14,6 +15,7 @@ require_relative "indexed_narrowing"
 require_relative "macro_block_self_type"
 require_relative "method_dispatcher"
 require_relative "narrowing"
+require_relative "struct_fold_safety"
 
 module Rigor
   module Inference
@@ -323,12 +325,7 @@ module Rigor
         dynamic_top
       end
 
-      # Recognised value-bearing position the Slice 2 engine does not yet
-      # narrow: self, instance/class/global variable reads, block bodies.
-      # Slice 3+ refines these in place; for now we acknowledge the node
-      # class so the coverage scanner stops flagging it without recording
-      # a fail-soft event for every occurrence.
-      # Slice A-engine. `Prism::SelfNode` resolves to the scope's
+      # `Prism::SelfNode` resolves to the scope's
       # `self_type` when one has been injected (by
       # `StatementEvaluator` at class-body and method-body
       # boundaries) or `Dynamic[Top]` at the top level. Class-body
@@ -412,7 +409,7 @@ module Rigor
       end
 
       def type_of_constant_path(node)
-        full_name = build_constant_path_name(node)
+        full_name = Source::ConstantPath.qualified_name_or_nil(node)
         return fallback_for(node, family: :prism) if full_name.nil?
 
         resolve_constant_name(full_name) || fallback_for(node, family: :prism)
@@ -481,24 +478,6 @@ module Rigor
         end
       end
 
-      # Builds the dotted-colon name for a `Foo`, `Foo::Bar`, or `::Foo`
-      # path. Returns nil when an inner segment is not itself a constant
-      # reference (for example `expr::Foo`), so the caller can fall back.
-      def build_constant_path_name(node)
-        case node
-        when Prism::ConstantReadNode
-          node.name.to_s
-        when Prism::ConstantPathNode
-          parent = node.parent
-          return node.name.to_s if parent.nil?
-
-          parent_name = build_constant_path_name(parent)
-          return nil if parent_name.nil?
-
-          "#{parent_name}::#{node.name}"
-        end
-      end
-
       # Slice 5 phase 1 upgrades hash literals to `HashShape{...}`
       # when every entry is a static `AssocNode` whose key is a
       # `SymbolNode` or `StringNode` with a known value (covering the
@@ -837,7 +816,7 @@ module Rigor
       # Other pattern shapes (Range, Regexp, custom `===`) stay
       # `:maybe` — the existing union fallback handles them.
       def case_when_pattern_certainty(subject_type, pattern_node)
-        class_name = build_constant_path_name(pattern_node)
+        class_name = Source::ConstantPath.qualified_name_or_nil(pattern_node)
         return Narrowing.class_pattern_certainty(subject_type, class_name, environment: scope.environment) if class_name
 
         literal = literal_pattern_value(pattern_node)
@@ -925,7 +904,8 @@ module Rigor
       end
 
       # `while` and `until` loops produce nil unless interrupted by
-      # `break VALUE`, which Slice 3 phase 1 does not yet model.
+      # `break VALUE`; the expression value of `break VALUE` is not yet
+      # modeled (scope break-path propagation landed in `eval_loop`).
       # Returning Constant[nil] is safe and matches Ruby semantics for
       # the common case.
       def type_of_loop(_node)
@@ -2382,7 +2362,19 @@ module Rigor
           environment: scope.environment,
           locals: locals.freeze,
           self_type: receiver,
-          discovery: scope.discovery
+          discovery: scope.discovery,
+          struct_fold_safe_locals: struct_fold_safe_locals_for(def_node.body)
+        )
+      end
+
+      # ADR-48 Struct slice 3 — the fold-safe-local set for a method body
+      # (runs only on a return-memo miss, so the per-call cost is bounded —
+      # measured perf-neutral). Struct member layouts of constant receivers
+      # are resolved through the discovery side-table the body scope inherits.
+      def struct_fold_safe_locals_for(body)
+        StructFoldSafety.fold_safe_locals(
+          body,
+          ->(name) { scope.struct_member_layout(name)&.[](:members) }
         )
       end
 

data/lib/rigor/inference/hkt_body.rb

@@ -7,18 +7,15 @@ module Rigor
     # piece of a Rigor-side type expression that the reducer
     # ({HktReducer}) walks against a concrete argument list.
     #
-    # Slice 2a ships a programmatic constructor surface only:
-    # plugin and Rigor-bundled overlay authors build a body
-    # tree by hand using these node types. The string-grammar
-    # parser that reads `Definition#body` (the raw String slot
-    # already populated by Slice 1's `HktDirectives.parse_define`)
-    # into a tree is Slice 2b's deliverable; until it ships, the
-    # `body` String stays opaque and `body_tree` is the
-    # evaluable form.
+    # Slice 2a ships a programmatic constructor surface; plugin
+    # and Rigor-bundled overlay authors may build a body tree
+    # by hand using these node types. The string-grammar parser
+    # (`HktBodyParser`, Slice 2b, shipped) reads `Definition#body`
+    # (populated by Slice 1's `HktDirectives.parse_define`) into
+    # this node tree; `body_tree` is the evaluable form.
     #
-    # The five node types cover the JSON.parse and dry-monads
-    # use cases ADR-20 § Implementation slicing names as
-    # near-term adopters:
+    # The nine node types cover JSON.parse, dry-monads, and the
+    # ADR-20 § D3 conditional / membership forms (shipped):
     #
     # - {TypeLeaf}    — wraps a fully-built `Rigor::Type`
     #   (use for atoms like `nil`, `Constant<true>`,

data/lib/rigor/inference/hkt_body_parser.rb

@@ -11,29 +11,27 @@ module Rigor
     # `%a{rigor:v1:hkt_define}` payloads) into the `HktBody`
     # node tree the Slice 2a reducer evaluates against.
     #
-    # The minimum-viable grammar covered here is the
-    # union-of-atoms-and-parameterised-forms subset of ADR-20
-    # § D3 — sufficient for `JSON.parse`'s `json::value`
-    # recursive sum and for any other recursive-data-shape
-    # signatures (Lisp value trees, dry-types refinements
-    # without conditionals). The conditional / indexed-access
-    # forms (`E <: T ? A : B`, `E in [k1, k2]`) drafted in D3
-    # remain a follow-up slice — bodies that contain `?`
-    # raise `ParseError` and the calling directive parser
-    # drops the body_tree (the body String remains stored and
-    # the reducer falls back to `app.bound`).
+    # The grammar implements the full ADR-20 § D3 subset:
+    # union-of-atoms/parameterised-forms for `JSON.parse`'s
+    # `json::value` recursive sum, plus the conditional and
+    # membership forms shipped in subsequent slices. Indexed-access
+    # forms remain deferred (no concrete demand yet).
     #
-    # ## Grammar (slice 2b)
+    # ## Grammar
     #
     #     body         := union
     #     union        := type_expr ("|" type_expr)*
     #     type_expr    := atom | nominal_app | app_ref | param
+    #                   | conditional
     #     atom         := "nil" | "true" | "false" | "bool" | "untyped"
     #     param        := UCNAME   (when UCNAME ∈ params)
     #     nominal_app  := class_name ("[" type_expr ("," type_expr)* "]")?
     #     class_name   := "::"? UCNAME ("::" UCNAME)*
     #     app_ref      := "App" "[" uri "," type_expr ("," type_expr)* "]"
     #     uri          := IDENT ("::" IDENT)+
+    #     conditional  := "(" test "?" union ":" union ")"
+    #     test         := type_expr ("<:" | "==") type_expr
+    #                   | type_expr "in" "[" type_expr ("," type_expr)* "]"
     #     UCNAME       := /[A-Z]\w*/
     #     IDENT        := /[a-z_]\w*/
     #

data/lib/rigor/inference/hkt_registry.rb

@@ -10,12 +10,12 @@ module Rigor
     # `%a{rigor:v1:hkt_define: ...}` annotations in shipped
     # `.rbs` files.
     #
-    # Slice 1 keeps the registry **opaque**: it stores the
-    # registration metadata (arity, variance, bound) and the
-    # un-evaluated definition body (a raw String — Slice 2
-    # introduces the conditional / indexed-access evaluator that
-    # parses the body and reduces `Type::App` instances against
-    # it). The carrier never needs to read from the registry
+    # The registry stores registration metadata (arity, variance,
+    # bound) and the definition body as both a raw String and an
+    # evaluable `HktBody` node tree. `HktReducer` (Slice 2a) and
+    # `HktBodyParser` (Slice 2b) are both shipped and reduce
+    # `Type::App` instances against the definition. The carrier
+    # never needs to read from the registry
     # because Slice 1's `Type::App` carries its `bound` directly;
     # the registry exists at this slice solely so the parser
     # round-trip and downstream slices have a stable target API.
@@ -65,16 +65,15 @@ module Rigor
       # definition.
       #
       # `body` is the raw String payload from the `%a{...}`
-      # annotation (Slice 1's parser populates it). It stays
-      # opaque until Slice 2b's body-string parser lands.
+      # annotation (Slice 1's parser populates it); parsed into
+      # `body_tree` by `HktBodyParser` (Slice 2b, shipped).
       #
-      # `body_tree` is the optional evaluable form: a
+      # `body_tree` is the evaluable form: a
       # `Rigor::Inference::HktBody::*` node tree the Slice 2a
       # reducer walks against the application's concrete
       # arguments. Plugin and Rigor-bundled overlay authors
       # construct it programmatically through
-      # {with_body_tree}; the Slice 2b string parser will set
-      # it from `body` once it ships. The reducer treats a
+      # {.definition_with_body_tree}. The reducer treats a
       # `nil` `body_tree` as "definition not yet evaluable"
       # and returns the registered bound.
       Definition = Data.define(:uri, :params, :body, :body_tree, :source_path, :source_line) do

data/lib/rigor/inference/method_dispatcher/call_context.rb

@@ -42,10 +42,7 @@ module Rigor
         #
         # This is the single place the call-context field list is
         # enumerated — the whole point of the value object is to absorb
-        # the wide keyword list the tiers used to each redeclare. The
-        # ParameterLists disable here retires the per-tier disables (the
-        # `RbsDispatch` quartet-plus signatures) rather than adding to
-        # them.
+        # the wide keyword list the tiers used to each redeclare.
         def self.build(receiver:, method_name:, args:, # rubocop:disable Metrics/ParameterLists
                        block_type: nil, environment: nil, call_node: nil,
                        scope: nil, self_type_override: nil, public_only: false)