rigortype 0.3.8 → 0.4.0

data/lib/rigor/bleeding_edge.rb

@@ -51,14 +51,14 @@ module Rigor
     # migration note and a user's `bleeding_edge:` list both key on.
     #
     # @!attribute id
-    #   @return [String] the stable feature id (contract vocabulary).
+    #   @return the stable feature id (contract vocabulary).
     # @!attribute summary
-    #   @return [String] a one-line description of what it changes. For a `:behaviour`
+    #   @return a one-line description of what it changes. For a `:behaviour`
     #     feature this is the *whole* explanation — there is no severity diff to read.
     # @!attribute kind
-    #   @return [Symbol] one of {KINDS}.
+    #   @return one of {KINDS}.
     # @!attribute severity_overrides
-    #   @return [Hash{String => Symbol}] canonical rule id → the severity this feature
+    #   @return canonical rule id → the severity this feature
     #     imposes. Composed *below* the user's own `severity_overrides:` and *above* the
     #     active `severity_profile` (see {Configuration::SeverityProfile.resolve}). Empty for
     #     a `:behaviour` feature.
@@ -76,12 +76,10 @@ module Rigor
         super
       end
 
-      # @return [Boolean]
       def severity?
         kind == :severity
       end
 
-      # @return [Boolean]
       def behaviour?
         kind == :behaviour
       end
@@ -193,36 +191,28 @@ module Rigor
     # cleanup can lag graduation by as many releases as it takes. The id also stays in the
     # contract vocabulary the CHANGELOG migration note keys on. Entries are removed only once
     # no call site names them.
-    #
-    # @return [Array<String>]
     GRADUATED = [].freeze
 
     module_function
 
-    # @return [Array<Feature>] the whole overlay.
     def features
       FEATURES
     end
 
-    # @return [Array<String>] every feature id in the overlay.
     def feature_ids
       FEATURES.map(&:id)
     end
 
-    # @param id [String]
-    # @return [Feature, nil]
     def feature(id)
       FEATURES.find { |f| f.id == id }
     end
 
-    # @param id [String]
-    # @return [Boolean] whether the id has graduated to default-on ({GRADUATED}).
+    # @return whether the id has graduated to default-on ({GRADUATED}).
     def graduated?(id)
       GRADUATED.include?(id)
     end
 
-    # @param id [String]
-    # @return [Boolean] whether the id names a feature this gem knows at all — queued or
+    # @return whether the id names a feature this gem knows at all — queued or
     #   graduated. Distinct from "adopted"; see {Configuration#bleeding_edge_active?}.
     def known_id?(id)
       graduated?(id) || FEATURES.any? { |f| f.id == id }
@@ -234,10 +224,9 @@ module Rigor
     # `severity_overrides:` keeps an unknown rule id inert until it lands (robust across gem
     # versions).
     #
-    # @param selector [Hash] `{ "mode" => "none" }`,
+    # @param selector — `{ "mode" => "none" }`,
     #   `{ "mode" => "all" }`, `{ "mode" => "all", "except" => [ids] }`,
     #   or `{ "mode" => "list", "ids" => [ids] }`.
-    # @return [Array<Feature>]
     def active_features(selector)
       case selector["mode"]
       when "all"
@@ -254,8 +243,7 @@ module Rigor
     # The merged severity-override map the active features impose for a selector. Frozen so
     # the result is `Ractor.shareable?`.
     #
-    # @param selector [Hash] see {#active_features}.
-    # @return [Hash{String => Symbol}]
+    # @param selector — see {#active_features}.
     def severity_overrides_for(selector)
       active_features(selector).each_with_object({}) do |feature, acc|
         acc.merge!(feature.severity_overrides)
@@ -267,8 +255,7 @@ module Rigor
     # Precomputed once per Configuration; frozen (with frozen members) so the carrier stays
     # `Ractor.shareable?` across the worker boundary.
     #
-    # @param selector [Hash] see {#active_features}.
-    # @return [Set<String>]
+    # @param selector — see {#active_features}.
     def active_ids_for(selector)
       Set.new(active_features(selector).map(&:id)).freeze
     end
@@ -276,8 +263,7 @@ module Rigor
     # Feature ids named by a selector that are NOT in the overlay (typo / graduated / from a
     # newer gem). Surfaced by `rigor show-bleedingedge` as a hint; never an error.
     #
-    # @param selector [Hash] see {#active_features}.
-    # @return [Array<String>]
+    # @param selector — see {#active_features}.
     def unknown_selected_ids(selector)
       named =
         case selector["mode"]

data/lib/rigor/builtins/hkt_builtins.rb

@@ -118,7 +118,7 @@ module Rigor
         )
       end
 
-      # @return [Rigor::Inference::HktRegistry] frozen registry
+      # @return frozen registry
       #   pre-seeded with all bundled HKT registrations +
       #   bodies. Allocated fresh each call rather than
       #   memoised — memoisation through a module-level
@@ -241,8 +241,9 @@ module Rigor
         ["CSV", :readlines,  :singleton] => CSV_PARSED_SPEC,
         ["CSV", :parse_line, :singleton] => CSV_ROW_SPEC
       }.freeze
+      Ractor.make_shareable(METHOD_RETURN_OVERRIDES)
 
-      # @return [Rigor::Type, nil] the reduced HKT type for
+      # @return the reduced HKT type for
       #   the given (class_name, method_name, kind) triple,
       #   or `nil` when no built-in override is registered.
       #   When `arg_types` is supplied AND the entry carries a

data/lib/rigor/builtins/imported_refinements.rb

@@ -31,11 +31,12 @@ module Rigor
     # - **No-argument refinement names** (`non-empty-string`, `non-zero-int`,
     #   `lowercase-string`, …) live in `REGISTRY` and resolve through `lookup(name)`.
     # - **Parameterised refinement payloads** (`non-empty-array[Integer]`,
-    #   `non-empty-hash[Symbol, Integer]`, `int<5, 10>`) are accepted by `parse(payload)`. The
-    #   full grammar is documented on `Parser`. The two surfaces share `REGISTRY` for the
-    #   no-arg head names; the parameterised head names live in `PARAMETERISED_TYPE_BUILDERS`
-    #   (square-bracket form, type args) and `PARAMETERISED_INT_BUILDERS` (angle-bracket form,
-    #   integer bounds).
+    #   `non-empty-hash[Symbol, Integer]`, `Integer[5..10]`, and the deprecated `int<5, 10>`)
+    #   are accepted by `parse(payload)`. The full grammar is documented on `Parser`. The two
+    #   surfaces share `REGISTRY` for the no-arg head names; the parameterised head names live
+    #   in `PARAMETERISED_TYPE_BUILDERS` (square-bracket form, type args), `RANGE_HEAD_BUILDERS`
+    #   (a numeric class over a range literal) and `PARAMETERISED_INT_BUILDERS` (the deprecated
+    #   angle-bracket form, integer bounds).
     module ImportedRefinements
       REGISTRY = {
         "non-empty-string" => -> { Type::Combinator.non_empty_string },
@@ -58,8 +59,12 @@ module Rigor
         "non-empty-lowercase-string" => -> { Type::Combinator.non_empty_lowercase_string },
         "non-empty-uppercase-string" => -> { Type::Combinator.non_empty_uppercase_string },
         "literal-string" => -> { Type::Combinator.literal_string },
-        "non-empty-literal-string" => -> { Type::Combinator.non_empty_literal_string }
+        "non-empty-literal-string" => -> { Type::Combinator.non_empty_literal_string },
+        # ADR-109 WD4 — names for the two Float ranges people mean most; each is an alias of a range.
+        "non-nan-float" => -> { Type::Combinator.non_nan_float },
+        "finite-float" => -> { Type::Combinator.finite_float }
       }.freeze
+      Ractor.make_shareable(REGISTRY)
       private_constant :REGISTRY
 
       # `name[T]` / `name[K, V]` — type-arg parameterised refinements. Each builder takes an
@@ -137,49 +142,91 @@ module Rigor
           Type::Combinator.readonly_of(args.first)
         }
       }.freeze
+      Ractor.make_shareable(PARAMETERISED_TYPE_BUILDERS)
       private_constant :PARAMETERISED_TYPE_BUILDERS
 
-      # `name<min, max>` — integer-bound parameterised refinements. Each builder takes an
+      # `Class[range]` — a numeric class head bounded by a Ruby range literal (ADR-109). The
+      # builder receives the `Range` value and returns the carrier, or `nil` when the range is
+      # empty or its endpoints are not literals of the head class; `nil` surfaces as the ordinary
+      # unresolved-payload diagnostic. `Float` joins this table with the `FloatRange` carrier.
+      RANGE_HEAD_BUILDERS = {
+        "Integer" => lambda { |range|
+          lo = range.begin
+          hi = range.end
+          return nil unless (lo.nil? || lo.is_a?(Integer)) && (hi.nil? || hi.is_a?(Integer))
+
+          # `1...10` is the set `1..9`: Integer ranges canonicalise to the closed form.
+          hi -= 1 if range.exclude_end? && hi.is_a?(Integer)
+          return nil if lo.is_a?(Integer) && hi.is_a?(Integer) && lo > hi
+
+          Type::Combinator.integer_range(lo || Type::IntegerRange::NEG_INFINITY, hi || Type::IntegerRange::POS_INFINITY)
+        },
+        # ADR-109 WD4 — `Float[R]` is the set of Floats `R.cover?` accepts. A missing or `nil` endpoint
+        # is the infinity on that side, except that `nil..nil` covers NaN in Ruby and so is `Float`
+        # itself; an Integer endpoint coerces (`(0..1).cover?(0.5)` is true); an exclusive end is kept
+        # (the carrier canonicalises it for equality), and an empty range declines.
+        "Float" => lambda { |range|
+          return Type::Combinator.nominal_of("Float") if range.begin.nil? && range.end.nil?
+
+          lo = ImportedRefinements.float_range_endpoint(range.begin, -Float::INFINITY)
+          hi = ImportedRefinements.float_range_endpoint(range.end, Float::INFINITY)
+          return nil if lo.nil? || hi.nil?
+
+          exclusive = range.exclude_end? && !range.end.nil?
+          return nil if lo > (exclusive ? hi.prev_float : hi)
+
+          Type::Combinator.float_range(lo, hi, exclude_end: exclusive)
+        }
+      }.freeze
+      Ractor.make_shareable(RANGE_HEAD_BUILDERS)
+      private_constant :RANGE_HEAD_BUILDERS
+
+      # `name<min, max>` — the PHPStan-style integer-bound form ADR-109 deprecates: still parsed so
+      # signatures written against v0.1–v0.3 keep resolving, never displayed. Each builder takes an
       # `Array<Integer>` and returns a `Rigor::Type` (or `nil`). Bounds are signed integer
-      # literals; `min` MUST be ≤ `max` for the carrier to construct successfully
-      # (`Type::IntegerRange` enforces the invariant).
+      # literals. A reversed pair (`min` > `max`) is declined as `nil` like every other shape
+      # mismatch, so the caller surfaces `dynamic.rbs-extended.unresolved` at the annotation;
+      # `Type::IntegerRange` raises on it instead, and that `ArgumentError` used to escape as an
+      # `internal analyzer error` that abandoned the whole Ruby file.
       PARAMETERISED_INT_BUILDERS = {
         "int" => lambda { |bounds|
           return nil unless bounds.size == 2
+          return nil if bounds[0] > bounds[1]
 
           Type::Combinator.integer_range(bounds[0], bounds[1])
         }
       }.freeze
+      Ractor.make_shareable(PARAMETERISED_INT_BUILDERS)
       private_constant :PARAMETERISED_INT_BUILDERS
 
       module_function
 
-      # @param name [String] kebab-case refinement name.
-      # @return [Rigor::Type, nil] the matching refinement carrier, or `nil` if the name is
+      # @param name — kebab-case refinement name.
+      # @return the matching refinement carrier, or `nil` if the name is
       #   not registered.
       def lookup(name)
         builder = REGISTRY[name.to_s]
         builder&.call
       end
 
-      # @param payload [String] the trailing payload of a `rigor:v1:return:` (or sibling)
+      # @param payload — the trailing payload of a `rigor:v1:return:` (or sibling)
       #   directive. Accepts the bare-name forms `lookup` already handles plus the
       #   parameterised forms documented on {Parser}.
-      # @param name_scope [Rigor::TypeNode::NameScope, nil]
+      # @param name_scope —
       #   ADR-13 slice 3 — when provided, the parser consults the scope's `#resolver` chain
       #   after the built-in registry and built-in parametric forms but before the RBS
       #   Nominal fallback. `nil` (default) preserves the slice-1 / slice-2 behaviour of
       #   consulting only built-ins + RBS.
-      # @param reporter [Rigor::RbsExtended::Reporter, nil]
+      # @param reporter —
       #   ADR-13 slice 3b — collector that the Resolver feeds `dynamic.shape.lossy-projection`
       #   events into when a shape-projection head (`pick_of`, `omit_of`, `partial_of`,
       #   `required_of`, `readonly_of`) is applied to a carrier that does not preserve shape
       #   information. `nil` (default) suppresses event accumulation; legacy call sites that
       #   have no reporter to thread keep the pre-slice-3b silent fall-through.
-      # @param source_location [RBS::Location, nil] location attribution for the events the
+      # @param source_location — location attribution for the events the
       #   Resolver records. Carries the annotation's filename / line / column so the runner
       #   can stamp diagnostics with the user-visible source site.
-      # @return [Rigor::Type, nil] the resolved refinement carrier, or `nil` when the payload
+      # @return the resolved refinement carrier, or `nil` when the payload
       #   is unparseable or names a refinement / class no registered source resolved.
       def parse(payload, name_scope: nil, reporter: nil, source_location: nil)
         Parser.new(
@@ -201,6 +248,20 @@ module Rigor
         PARAMETERISED_INT_BUILDERS[name]
       end
 
+      def range_head_builder(name)
+        RANGE_HEAD_BUILDERS[name]
+      end
+
+      # A Float-head range endpoint as a double: `nil` (absent) is `default`, an Integer literal
+      # coerces, a non-NaN Float stands, anything else declines with `nil`.
+      def float_range_endpoint(value, default)
+        case value
+        when nil then default
+        when Integer then value.to_f
+        when Float then value.nan? ? nil : value
+        end
+      end
+
       def known?(name)
         REGISTRY.key?(name.to_s) ||
           PARAMETERISED_TYPE_BUILDERS.key?(name.to_s) ||
@@ -219,8 +280,10 @@ module Rigor
       #   parametric  := simple_name '[' type_arg_list ']'
       #                | simple_name '<' int_bound_list '>'
       #   type_arg_list := type_arg (',' type_arg)*
-      #   type_arg    := type | class_name
+      #   type_arg    := range_literal | type | class_name
       #   class_name  := /[A-Z][A-Za-z0-9_]*(?:::[A-Z][A-Za-z0-9_]*)*/
+      #   range_literal := endpoint? ('..' | '...') endpoint?     (at least one side written)
+      #   endpoint    := signed_int | 'nil'
       #   int_bound_list := signed_int (',' signed_int)*
       #   signed_int  := /-?\d+/
       #
@@ -274,7 +337,16 @@ module Rigor
         # delimiter.
         SYMBOL_LITERAL = /:(?<value>[a-zA-Z_][a-zA-Z0-9_]*[?!=]?)/
         STRING_LITERAL = /"(?<value>[^"\\]*)"/
-        private_constant :SIMPLE_NAME, :CLASS_NAME, :SIGNED_INT, :SYMBOL_LITERAL, :STRING_LITERAL
+        # ADR-109 — a Ruby range literal at type-arg position, `1..10` / `1...10` / `1..` / `..10` /
+        # `nil..nil`, and for the Float head `0.0...1.0` / `1e-3..` / `-Float::INFINITY..Float::MAX`.
+        # Tried before the class-name and integer scans so `Float::INFINITY..` and `1..10` are not
+        # consumed as a class name or a bare integer; the operator is mandatory, so a bare integer or
+        # constant never matches. `..` with nothing on either side is not Ruby and is rejected after
+        # the match.
+        RANGE_ENDPOINT = /-?(?:\d+(?:\.\d+)?(?:[eE][+-]?\d+)?|Float::INFINITY|Float::MAX)|nil/
+        RANGE_LITERAL = /(?<lo>#{RANGE_ENDPOINT})?\s*(?<op>\.\.\.?)\s*(?<hi>#{RANGE_ENDPOINT})?/
+        private_constant :SIMPLE_NAME, :CLASS_NAME, :SIGNED_INT, :SYMBOL_LITERAL, :STRING_LITERAL,
+                         :RANGE_ENDPOINT, :RANGE_LITERAL
 
         def parse_type_ast
           if (class_name = @scanner.scan(CLASS_NAME))
@@ -382,7 +454,9 @@ module Rigor
         end
 
         def parse_single_type_arg_ast
-          if (class_name = @scanner.scan(CLASS_NAME))
+          if (range = scan_range_literal)
+            range
+          elsif (class_name = @scanner.scan(CLASS_NAME))
             parse_class_arg_tail_ast(class_name)
           elsif (literal = @scanner.scan(SIGNED_INT))
             TypeNode::IntegerLiteral.new(value: Integer(literal))
@@ -421,6 +495,36 @@ module Rigor
           Integer(literal)
         end
 
+        # Returns a {TypeNode::RangeLiteral} when the scanner sits on a Ruby range literal, `nil`
+        # (without consuming input) otherwise. `nil` and an absent endpoint both become Ruby's
+        # `nil` endpoint; the two spellings denote the same range.
+        def scan_range_literal
+          return nil unless @scanner.scan(RANGE_LITERAL)
+
+          lo = @scanner[:lo]
+          hi = @scanner[:hi]
+          return nil if lo.nil? && hi.nil?
+
+          TypeNode::RangeLiteral.new(
+            value: Range.new(range_endpoint(lo), range_endpoint(hi), @scanner[:op] == "...")
+          )
+        end
+
+        # The endpoint as the Ruby value the token denotes: an Integer literal stays an Integer (the
+        # `Integer` head needs to tell `1` from `1.0`), a Float literal or one of the four spelled
+        # constants becomes the double.
+        def range_endpoint(token)
+          case token
+          when nil, "nil" then nil
+          when "Float::INFINITY" then Float::INFINITY
+          when "-Float::INFINITY" then -Float::INFINITY
+          when "Float::MAX" then Float::MAX
+          when "-Float::MAX" then -Float::MAX
+          when /[.eE]/ then Float(token)
+          else Integer(token)
+          end
+        end
+
         def skip_ws
           @scanner.skip(/\s+/)
         end
@@ -463,7 +567,7 @@ module Rigor
         # `StringLiteral`) carries a Ruby value that lifts directly to a `Constant<value>`
         # carrier through the same helper.
         LITERAL_AST_NODES = [
-          TypeNode::IntegerLiteral, TypeNode::SymbolLiteral, TypeNode::StringLiteral
+          TypeNode::IntegerLiteral, TypeNode::SymbolLiteral, TypeNode::StringLiteral, TypeNode::RangeLiteral
         ].freeze
         private_constant :LITERAL_AST_NODES
 
@@ -519,6 +623,11 @@ module Rigor
         end
 
         def resolve_generic(node)
+          # ADR-109 — `Integer[1..10]`. A range literal under a numeric head is that head's range
+          # refinement or nothing: an empty or malformed range declines here rather than falling
+          # through to a `Nominal[Integer, [Constant<Range>]]` the RBS fallback would otherwise build.
+          return resolve_range_head(node) if range_headed?(node)
+
           builtin = try_builtin_parametric(node)
           return builtin unless builtin.nil?
 
@@ -547,6 +656,19 @@ module Rigor
           try_parametric_type_builder(node) || try_parametric_int_builder(node)
         end
 
+        def range_headed?(node)
+          !ImportedRefinements.range_head_builder(node.head).nil? &&
+            node.args.any?(TypeNode::RangeLiteral)
+        end
+
+        # Exactly one range literal under the head; `Integer[1..10, 3]` is not a range refinement.
+        # Anything else under the same head (`Integer[Foo]`) keeps its pre-ADR-109 path.
+        def resolve_range_head(node)
+          return nil unless node.args.size == 1
+
+          ImportedRefinements.range_head_builder(node.head).call(node.args.first.value)
+        end
+
         def try_parametric_type_builder(node)
           builder = ImportedRefinements.parametric_type_builder(node.head)
           return nil if builder.nil?
@@ -585,7 +707,23 @@ module Rigor
           bounds = node.args.map { |a| a.is_a?(TypeNode::IntegerLiteral) ? a.value : nil }
           return nil if bounds.any?(&:nil?)
 
-          builder.call(bounds)
+          result = builder.call(bounds)
+          record_deprecated_form(node, bounds, result) unless result.nil?
+          result
+        end
+
+        # ADR-109 WD3 — the angle-bracket form still resolves, and the run says so once per annotation with
+        # the spelling the same type now displays as. Recorded only when the payload resolved: an
+        # unresolvable one already surfaces as `dynamic.rbs-extended.unresolved`, and a second row for it
+        # would name a replacement for something that never parsed.
+        def record_deprecated_form(node, bounds, result)
+          return if @reporter.nil?
+
+          path, line, column = RbsExtended::Reporter.position_of(@source_location)
+          @reporter.record_deprecated_form(
+            payload: "#{node.head}<#{bounds.join(', ')}>", replacement: result.describe,
+            path: path, line: line, column: column
+          )
         end
 
         def resolve_args(args)

data/lib/rigor/builtins/predefined_constant_refinements.rb

@@ -117,8 +117,7 @@ module Rigor
 
       # --- private ------------------------------------------------------
 
-      # @param value [String] a non-empty string
-      # @return [Rigor::Type]
+      # @param value — a non-empty string
       def self.classify_string(value)
         if Type::Refined.ruby_numeric_literal?(value)
           NUMERIC_STRING
@@ -133,8 +132,7 @@ module Rigor
       # Called ONLY with the names in {RUNTIME_STRING_CONSTANTS} — Rigor's own source — and only
       # while this file is being loaded. It is never handed a name from the analysed program.
       #
-      # @param name [String] a qualified constant path without a leading "::"
-      # @return [String, nil]
+      # @param name — a qualified constant path without a leading "::"
       def self.runtime_string_value(name)
         mod = ::Object
         name.split("::").each do |part|
@@ -161,7 +159,7 @@ module Rigor
       end
       private_class_method :runtime_string_value
 
-      # @return [Hash{String => Rigor::Type}] frozen, built once at load time.
+      # @return frozen, built once at load time.
       def self.build_runtime_string_refinements
         RUNTIME_STRING_CONSTANTS.each_with_object({}) do |name, table|
           value = runtime_string_value(name)
@@ -175,9 +173,9 @@ module Rigor
 
       # --- public API ---------------------------------------------------
 
-      # @param name [String] unqualified constant name (e.g. `"Math::PI"`,
+      # @param name — unqualified constant name (e.g. `"Math::PI"`,
       #   `"RUBY_VERSION"`, `"Ruby::ENGINE"`)
-      # @return [Rigor::Type, nil] refined type, or nil to fall through
+      # @return refined type, or nil to fall through
       def self.lookup(name)
         FOLDED_CONSTANTS[name] || RUNTIME_STRING_REFINEMENTS[name]
       end

data/lib/rigor/builtins/regex_refinement.rb

@@ -20,14 +20,22 @@ module Rigor
     # `{n,m}` forms with `n >= 1`):
     #
     #   - `\d`, `[0-9]`            -> decimal-int-string
-    #   - `\h`                     -> hex-int-string
-    #   - `[0-9a-fA-F]`            -> hex-int-string
-    #   - `[0-9a-f]`, `[0-9A-F]`   -> hex-int-string
-    #   - `[0-7]`                  -> octal-int-string
+    #   - `\h`                     -> non-empty-string
+    #   - `[0-9a-fA-F]`            -> non-empty-string
+    #   - `[0-9a-f]`, `[0-9A-F]`   -> non-empty-string
+    #   - `[0-7]`                  -> non-empty-string
     #   - `[a-z]`                  -> lowercase-string
     #   - `[A-Z]`                  -> uppercase-string
     #   - `[[:digit:]]`            -> numeric-string
     #
+    # #1004 — the hex/octal digit classes do NOT map to `hex-int-string` / `octal-int-string`.
+    # Those refinements' predicates (`Type::Refined` PREDICATES, in `type/refined.rb`) REQUIRE the
+    # conventional `0x` / `0o` prefix, but a bare digit class like `[0-9a-fA-F]+` matches "ff" —
+    # a string with no prefix at all. Mapping a matched digit run to a refinement its own
+    # predicate rejects is unsound (worse than the plain `String` it replaces), so these rows
+    # drop to `non-empty-string`: the `+` / `{n,}` (n >= 1) quantifier already guarantees the
+    # captured run is never empty, and that much is true regardless of prefix.
+    #
     # Anything outside the table returns `nil` so the calling narrowing site falls back to
     # its previous behaviour (plain `String`). Arbitrary regex semantic equivalence is
     # undecidable, so the table is intentionally a small audited set of canonical shapes
@@ -46,11 +54,11 @@ module Rigor
       RULES = Ractor.make_shareable([
                                       [/\A\\d#{QUANTIFIER_SOURCE}\z/, :decimal_int_string],
                                       [/\A\[0-9\]#{QUANTIFIER_SOURCE}\z/, :decimal_int_string],
-                                      [/\A\\h#{QUANTIFIER_SOURCE}\z/, :hex_int_string],
-                                      [/\A\[0-9a-fA-F\]#{QUANTIFIER_SOURCE}\z/, :hex_int_string],
-                                      [/\A\[0-9a-f\]#{QUANTIFIER_SOURCE}\z/, :hex_int_string],
-                                      [/\A\[0-9A-F\]#{QUANTIFIER_SOURCE}\z/, :hex_int_string],
-                                      [/\A\[0-7\]#{QUANTIFIER_SOURCE}\z/, :octal_int_string],
+                                      [/\A\\h#{QUANTIFIER_SOURCE}\z/, :non_empty_string],
+                                      [/\A\[0-9a-fA-F\]#{QUANTIFIER_SOURCE}\z/, :non_empty_string],
+                                      [/\A\[0-9a-f\]#{QUANTIFIER_SOURCE}\z/, :non_empty_string],
+                                      [/\A\[0-9A-F\]#{QUANTIFIER_SOURCE}\z/, :non_empty_string],
+                                      [/\A\[0-7\]#{QUANTIFIER_SOURCE}\z/, :non_empty_string],
                                       [/\A\[a-z\]#{QUANTIFIER_SOURCE}\z/, :lowercase_string],
                                       [/\A\[A-Z\]#{QUANTIFIER_SOURCE}\z/, :uppercase_string],
                                       [/\A\[\[:digit:\]\]#{QUANTIFIER_SOURCE}\z/, :numeric_string]
@@ -62,11 +70,11 @@ module Rigor
 
       module_function
 
-      # @param body [String, nil] a regex sub-pattern, typically the inner body of a
+      # @param body — a regex sub-pattern, typically the inner body of a
       #   `(?<name>body)` named capture. Anchors (`\A`, `\z`, `^`, `$`) are not stripped — the
       #   recogniser table targets bodies that the regex engine treats as anchored to the
       #   capture group bounds.
-      # @return [Rigor::Type, nil] the matching imported refinement carrier, or `nil` if
+      # @return the matching imported refinement carrier, or `nil` if
       #   `body` is not a recognised shape.
       def for_capture_body(body)
         return nil if body.nil? || body.empty?
@@ -100,8 +108,8 @@ module Rigor
       # free-whitespace/`#`-comment flag from the `source` alone, so consumers bail on it before
       # calling here.
       #
-      # @param source [String, nil] the full regex source string.
-      # @return [Rigor::Type, nil] the matching imported refinement carrier, or `nil`.
+      # @param source — the full regex source string.
+      # @return the matching imported refinement carrier, or `nil`.
       def for_whole_pattern(source)
         return nil if source.nil?
         return nil unless source.start_with?('\A') && source.end_with?('\z')

data/lib/rigor/builtins/static_return_refinements.rb

@@ -93,20 +93,20 @@ module Rigor
         ["IO", :read, :singleton] => IO_READ_NO_LENGTH,
         ["File", :read, :singleton] => IO_READ_NO_LENGTH
       }.freeze
+      Ractor.make_shareable(OVERRIDES)
       private_constant :OVERRIDES
 
       # Looks up a refined return type for the given call.
       #
-      # @param owner_class_name [String, nil] the class on which the method is defined
+      # @param owner_class_name — the class on which the method is defined
       #   (e.g., `"Kernel"`). Pass `nil` when the caller hasn't resolved a defining owner
       #   yet — the lookup will then fall back to matching by `(method_name, kind)` against
       #   entries whose owner is currently in the table.
-      # @param method_name [Symbol]
-      # @param kind [Symbol] one of `:singleton`, `:instance`. The caller passes the shape of
+      # @param kind — one of `:singleton`, `:instance`. The caller passes the shape of
       #   the actual call site; the table stores `:both` for entries that match either.
-      # @param arg_types [Array<Rigor::Type>] positional argument types. Forwarded to the
+      # @param arg_types — positional argument types. Forwarded to the
       #   handler so future entries can discriminate on argument shape.
-      # @return [Rigor::Type, nil] the refined return type, or `nil` when no override
+      # @return the refined return type, or `nil` when no override
       #   matches.
       def self.lookup(owner_class_name:, method_name:, kind:, arg_types: [])
         return nil if owner_class_name.nil?
@@ -125,9 +125,10 @@ module Rigor
         acc[mname] ||= []
         acc[mname] << owner unless acc[mname].include?(owner)
       end.freeze
+      Ractor.make_shareable(OWNERS_BY_METHOD)
       private_constant :OWNERS_BY_METHOD
 
-      # @return [Array<String>] the candidate owner class names for a bare method-name
+      # @return the candidate owner class names for a bare method-name
       #   lookup. Empty when no override names this method.
       NO_OWNERS = [].freeze
       private_constant :NO_OWNERS

data/lib/rigor/cache/annotation_location.rb

@@ -41,8 +41,7 @@ module Rigor
 
       module_function
 
-      # @param location [RBS::Location, nil]
-      # @return [Array, nil] `[name, start_line, start_column, end_line, end_column]`, or nil when there is
+      # @return `[name, start_line, start_column, end_line, end_column]`, or nil when there is
       #   no location to carry. Fail-soft: a location whose buffer cannot answer is dumped as nil rather
       #   than failing the whole environment's dump.
       def dump(location)
@@ -55,8 +54,7 @@ module Rigor
         nil
       end
 
-      # @param payload [Array, nil] what {dump} produced.
-      # @return [RBS::Location, nil]
+      # @param payload — what {dump} produced.
       def load(payload)
         return nil if payload.nil?