rigortype 0.3.7 → 0.3.9

data/lib/rigor/analysis/worker_session.rb

@@ -3,6 +3,7 @@
 require "prism"
 
 require_relative "../environment"
+require_relative "../project_environment"
 require_relative "../scope"
 require_relative "../cache/store"
 require_relative "../plugin"
@@ -16,6 +17,7 @@ require_relative "../effects/envelope_index"
 require_relative "../inference/scope_indexer"
 require_relative "../inference/method_dispatcher/file_folding"
 require_relative "check_rules"
+require_relative "crash_signature"
 require_relative "dependency_recorder"
 require_relative "dependency_source_inference"
 require_relative "diagnostic"
@@ -72,12 +74,11 @@ module Rigor
                   :rbs_extended_reporter, :boundary_cross_reporter,
                   :prepare_diagnostics
 
-      # @param configuration [Rigor::Configuration]
-      # @param cache_store [Rigor::Cache::Store, nil] persistent cache the session exposes to plugin-side
+      # @param cache_store — persistent cache the session exposes to plugin-side
       #   producers and the RBS loader. Pass `nil` to disable caching.
-      # @param plugin_blueprints [Array<Rigor::Plugin::Blueprint>] replay descriptors. Empty array yields a
+      # @param plugin_blueprints — replay descriptors. Empty array yields a
       #   session with no plugin contributions.
-      # @param explain [Boolean] when true, `#analyze` additionally emits one `:info` `fallback` diagnostic
+      # @param explain — when true, `#analyze` additionally emits one `:info` `fallback` diagnostic
       #   per directly-unrecognised node, mirroring {Rigor::Analysis::Runner#explain_diagnostics}.
       def initialize(configuration:, cache_store: nil, # rubocop:disable Metrics/MethodLength,Metrics/ParameterLists
                      plugin_blueprints: [], explain: false, buffer: nil,
@@ -136,11 +137,7 @@ module Rigor
           rbs_extended_reporter: @rbs_extended_reporter,
           boundary_cross_reporter: @boundary_cross_reporter,
           source_rbs_synthesis_reporter: @source_rbs_synthesis_reporter,
-          bundler_bundle_path: configuration.bundler_bundle_path,
-          bundler_auto_detect: configuration.bundler_auto_detect,
-          bundler_lockfile: configuration.bundler_lockfile,
-          rbs_collection_lockfile: configuration.rbs_collection_lockfile,
-          rbs_collection_auto_detect: configuration.rbs_collection_auto_detect,
+          **ProjectEnvironment.dependency_discovery_options(configuration),
           synthetic_method_index: @synthetic_method_index,
           project_patched_methods: @project_patched_methods,
           source_files: @source_files
@@ -228,7 +225,7 @@ module Rigor
       rescue Errno::ENOENT => e
         [analyzer_error(path, e.message)]
       rescue StandardError => e
-        [analyzer_error(path, "internal analyzer error: #{e.class}: #{e.message}")]
+        [analyzer_error(path, CrashSignature.check_rule_message(e))]
       end
       private :analyze_body
 
@@ -243,15 +240,42 @@ module Rigor
       # how you ran it" defect the diagnostic exists to end. Draining it out of the workers is what makes
       # the two paths say the same thing. The payload is `[String, String, String, Array<String>]` tuples —
       # Marshal-clean for the fork backend and shareable for the Ractor one.
+      #
+      # Issue #784 — `hkt_scan_failure` rides the same channel for the same reason: the PARENT's own
+      # Environment never demands `#hkt_registry` under the pool, so its slot is always nil, and draining it
+      # out of the workers is the only way `--workers=N` says what `--workers=0` says.
+      #
+      # Issue #805 — the Marshal-clean requirement binds every stream here, not just the ones written for it.
+      # The `RbsExtended::Reporter`'s unresolved / lossy-projection entries used to carry the `RBS::Location`
+      # itself, and `Marshal.dump` on one raises `TypeError` (a C-extension object with no `_dump`), so a
+      # project whose `sig/` produced a single such event killed each worker HERE — after its files were
+      # analysed — and the run degraded to in-process re-analysis with a `pool-degraded` row. All three
+      # streams now carry `(path, line, column)` primitives.
       def drain_reporters
+        # Issue #784 — demand the registry once per worker before reading the slot, so a worker whose share
+        # of files happened to contain no `Klass.method` call still reports the run's outcome (the same
+        # reason `PoolCoordinator#hkt_scan_outcome` demands it on the sequential path). The Environment
+        # object is built in the constructor, but its RBS env is lazy: on a worker that analysed a file this
+        # is a memoised read; on one that demanded nothing it is the same cache-served env load that file
+        # would have paid. The fork backend never hands a worker an empty slice, so no idle worker pays it.
+        @environment&.hkt_registry
         {
           rbs_extended: {
             unresolved_payloads: @rbs_extended_reporter.unresolved_payloads,
-            lossy_projections: @rbs_extended_reporter.lossy_projections
+            lossy_projections: @rbs_extended_reporter.lossy_projections,
+            # Issue #785 — the HKT directive stream rides the same channel for the same reason
+            # `hkt_scan_failure` does: the directives are read by the registry scan, and under the pool the
+            # PARENT never demands that scan, so a diagnostic wired off the parent's reporter would appear
+            # at `--workers=0` and vanish at `--workers=N`. The demand above is what fills this.
+            hkt_directive_errors: @rbs_extended_reporter.hkt_directive_errors,
+            # ADR-109 WD3 — the deprecated-form stream rides the same channel: the payload is read where
+            # the annotated method is dispatched, which under the pool is only ever inside a worker.
+            deprecated_forms: @rbs_extended_reporter.deprecated_forms
           },
           boundary_cross: @boundary_cross_reporter.entries,
           source_rbs_synthesis: @source_rbs_synthesis_reporter.entries,
-          definition_build_failures: @environment&.rbs_loader&.definition_build_failures || []
+          definition_build_failures: @environment&.rbs_loader&.definition_build_failures || [],
+          hkt_scan_failure: @environment&.hkt_scan_failure
         }
       end
 

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,30 @@ 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.
+    # @return the whole overlay.
     def features
       FEATURES
     end
 
-    # @return [Array<String>] every feature id in the overlay.
+    # @return 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 +226,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 +245,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 +257,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 +265,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
@@ -242,7 +242,7 @@ module Rigor
         ["CSV", :parse_line, :singleton] => CSV_ROW_SPEC
       }.freeze
 
-      # @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

@@ -2,6 +2,7 @@
 
 require "strscan"
 
+require_relative "../rbs_extended/reporter"
 require_relative "../type"
 require_relative "../type_node"
 
@@ -30,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 },
@@ -57,7 +59,10 @@ 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
       private_constant :REGISTRY
 
@@ -138,13 +143,52 @@ module Rigor
       }.freeze
       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
+      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])
         }
@@ -153,32 +197,32 @@ module Rigor
 
       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(
@@ -200,6 +244,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) ||
@@ -218,8 +276,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+/
       #
@@ -273,7 +333,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))
@@ -381,7 +450,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))
@@ -420,6 +491,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
@@ -462,7 +563,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
 
@@ -518,6 +619,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?
 
@@ -546,6 +652,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?
@@ -558,11 +677,14 @@ module Rigor
           result
         end
 
-        # ADR-13 slice 3b — record one `dynamic.shape.lossy-projection` event per (head,
-        # source_location) pair when the projection actually degraded. The builders return
-        # the source carrier unchanged on non-HashShape / non-Tuple receivers (see
-        # `Type::Combinator.pick_of` / `omit_of` and the HashShape-only `partial_of` /
-        # `required_of` / `readonly_of`), so detection is "first arg was lossy".
+        # ADR-13 slice 3b — record one `dynamic.shape.lossy-projection` event per (head, position) pair when
+        # the projection actually degraded. The builders return the source carrier unchanged on
+        # non-HashShape / non-Tuple receivers (see `Type::Combinator.pick_of` / `omit_of` and the
+        # HashShape-only `partial_of` / `required_of` / `readonly_of`), so detection is "first arg was lossy".
+        #
+        # Issue #805 — the `RBS::Location` is flattened to `(path, line, column)` here, at record time: the
+        # entry is drained out of every fork-pool worker, and a location survives neither the drain's
+        # `Marshal.dump` nor its cross-worker dedup (see {Rigor::RbsExtended::Reporter}).
         def record_lossy_projection_if_applicable(node, args, result)
           return if @reporter.nil?
           return if result.nil?
@@ -570,10 +692,8 @@ module Rigor
           return if args.empty?
           return unless Type::Combinator.shape_projection_lossy?(args.first)
 
-          @reporter.record_lossy_projection(
-            head: node.head,
-            source_location: @source_location
-          )
+          path, line, column = RbsExtended::Reporter.position_of(@source_location)
+          @reporter.record_lossy_projection(head: node.head, path: path, line: line, column: column)
         end
 
         def try_parametric_int_builder(node)
@@ -583,7 +703,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

@@ -62,11 +62,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 +100,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

@@ -97,16 +97,15 @@ module Rigor
 
       # 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?
@@ -127,7 +126,7 @@ module Rigor
       end.freeze
       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