rigortype 0.3.7 → 0.3.8

data/lib/rigor/analysis/worker_session.rb

@@ -16,6 +16,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"
@@ -228,7 +229,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 +244,39 @@ 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
           },
           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/builtins/imported_refinements.rb

@@ -2,6 +2,7 @@
 
 require "strscan"
 
+require_relative "../rbs_extended/reporter"
 require_relative "../type"
 require_relative "../type_node"
 
@@ -558,11 +559,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 +574,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)

data/lib/rigor/cache/annotation_location.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require "rbs"
+
+module Rigor
+  module Cache
+    # The `RBS::AST::Annotation` location carry (issue #799): the two halves of the `marshal_dump` /
+    # `marshal_load` pair {file:lib/rigor/cache/rbs_environment_marshal_patch.rb the env-cache Marshal patch}
+    # installs on `RBS::AST::Annotation`, plus the buffer a reconstructed location points at. That file's
+    # header carries the why; this one is the how.
+    #
+    # Nothing here reconstructs the annotation's SOURCE — the cached env has no file contents, and a
+    # consumer that wants the text already has `Annotation#string`. What it reconstructs is the pair of
+    # `(line, column)` answers `RBS::Location` gives, so a diagnostic positioned on the directive reads the
+    # same line warm as it does cold.
+    module AnnotationLocation
+      # The two positions {Buffer} distinguishes. `RBS::Location` addresses its buffer by character
+      # offset, and the reconstruction has no content to offset into, so the offsets are used as tags:
+      # 0 is "the start pair", 1 is "the end pair".
+      START_POS = 0
+      END_POS = 1
+
+      # A content-less `RBS::Buffer` that answers `pos_to_loc` from the pairs the cold parse had.
+      #
+      # Answering there is all it takes: `RBS::Location#start_line` and its three siblings are C methods
+      # that resolve the offset through `buffer.pos_to_loc`, so the reconstructed Location reports the real
+      # position without the buffer having to hold (or synthesize) the file it came from. The alternative —
+      # a synthetic content string of `line - 1` newlines — is exact only while an annotation stays on one
+      # line, and `%a{...}` may span two.
+      class Buffer < ::RBS::Buffer
+        def initialize(name:, start_loc:, end_loc:)
+          super(name: name, content: "")
+          @start_loc = start_loc
+          @end_loc = end_loc
+        end
+
+        def pos_to_loc(pos)
+          pos == START_POS ? @start_loc : @end_loc
+        end
+      end
+
+      module_function
+
+      # @param location [RBS::Location, nil]
+      # @return [Array, nil] `[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)
+        return nil if location.nil?
+
+        buffer = location.buffer
+        name = buffer.respond_to?(:name) ? buffer.name.to_s : nil
+        [name, location.start_line, location.start_column, location.end_line, location.end_column]
+      rescue StandardError
+        nil
+      end
+
+      # @param payload [Array, nil] what {dump} produced.
+      # @return [RBS::Location, nil]
+      def load(payload)
+        return nil if payload.nil?
+
+        name, start_line, start_column, end_line, end_column = payload
+        name = ::RBS::Location::CACHED_BUFFER_NAME if name.nil? || name.empty?
+        buffer = Buffer.new(name: name, start_loc: [start_line, start_column], end_loc: [end_line, end_column])
+        ::RBS::Location.new(buffer: buffer, start_pos: START_POS, end_pos: END_POS)
+      rescue StandardError
+        nil
+      end
+    end
+  end
+end

data/lib/rigor/cache/rbs_environment_marshal_patch.rb

@@ -2,6 +2,8 @@
 
 require "rbs"
 
+require_relative "annotation_location"
+
 # Adds `_dump` / `_load` to {RBS::Location} so an `RBS::Environment` (and its transitive AST nodes, all of
 # which carry Locations) round-trips through `Marshal`. The rbs gem's C-extension `RBS::Location` ships
 # without the Marshal hooks; until rbs grows them upstream this patch is the minimal monkey-patch the v0.0.9
@@ -31,6 +33,25 @@ require "rbs"
 #   than a cold run does. ADR-6's store never evicts, so that would persist. `Cache::Store::FORMAT_VERSION`
 #   is therefore bumped to 3: `PAYLOAD_ABI_VERSION` already rebuilds across a release, and the bump closes
 #   the same-version window too.
+# - `RBS::AST::Annotation` carries its own `marshal_dump` / `marshal_load`, which keep the annotation's
+#   POSITION as well as its file (issue #799). "Nothing reads positions" was never quite true: the two
+#   `conforms-to` rows — `rbs_extended.unsatisfied-conformance` and `dynamic.rbs-extended.unresolved` —
+#   are reported AT the directive, because there is no Ruby `def` a missing interface method could be
+#   reported at, so both read `start_line` / `start_column` off an annotation's location. (They are the
+#   only readers: {Rigor::RbsExtended::EnvelopeScanner} positions `effect.unknown-label` at an annotation
+#   too, but reaches it by parsing the project's own `.rbs` rather than the built env — refusing this very
+#   loss is one of the two reasons it does.) Cold the row is `sig/buffer.rbs:6:1`; through a `_dump`ed
+#   location it collapsed to `1:1`, which made `--verify-incremental` fail outright on any project carrying
+#   an unsatisfied directive (the replica normalises rows by position, and only one side of the comparison
+#   runs against the cached env) and made a warm `--incremental` run move a row on a tree that had not
+#   changed. The carry is scoped to annotations rather than done in `_dump` for the reason the paragraph
+#   above gives: a Location hangs off every AST node, and carrying its position measured +2.9% on Rigor's
+#   own env (9,941K to 10,229K) on top of the names. An annotation is rare by comparison — 18 of them in
+#   that same env — so the same carry costs +1.4K there, which is the whole argument for scoping it here
+#   rather than widening `_dump`. `Cache::Store::FORMAT_VERSION` is bumped to 4 for the same reason it was
+#   bumped to 3: a pre-change blob still loads (Marshal encodes an ivar dump and a `marshal_dump` payload
+#   differently, and only the latter reaches `marshal_load`), so without the bump a stale blob would keep
+#   reporting the moved position indefinitely.
 #
 # Idempotent: the guard checks `method_defined?(:_dump)` so requiring this file twice (or against an upstream
 # rbs that adds Marshal hooks itself) is a no-op.
@@ -67,6 +88,24 @@ module RBS
     end
   end
 
+  module AST
+    class Annotation
+      # Carries the annotation's POSITION across the cache, not just its file. See the header's fourth
+      # bullet for why this one AST node opts out of the position-dropping `RBS::Location#_dump` above.
+      unless method_defined?(:marshal_dump)
+        def marshal_dump
+          [string, Rigor::Cache::AnnotationLocation.dump(location)]
+        end
+
+        def marshal_load(payload)
+          dumped_string, dumped_location = payload
+          @string = dumped_string
+          @location = Rigor::Cache::AnnotationLocation.load(dumped_location)
+        end
+      end
+    end
+  end
+
   class Namespace
     unless method_defined?(:_dump)
       def _dump(_)

data/lib/rigor/cache/store.rb

@@ -38,7 +38,14 @@ module Rigor
       # `PAYLOAD_ABI_VERSION` already rebuilds across a RELEASE, so the exposure is a same-version tree; this
       # closes that window too, because "the same project reports differently depending on how you ran it" is
       # the defect the diagnostic exists to end and a stale blob reintroduces it.
-      FORMAT_VERSION = 3
+      #
+      # v4 (issue #799): `RBS::AST::Annotation` now carries its own `marshal_dump` / `marshal_load`, which
+      # keep the annotation's POSITION as well as its file, so `rbs_extended.unsatisfied-conformance` points
+      # at the `%a{rigor:v1:conforms-to …}` line warm as well as cold. A pre-change blob loads perfectly well
+      # — Marshal encodes an ivar dump and a `marshal_dump` payload differently, and only the latter reaches
+      # `marshal_load` — which is exactly the problem: without a bump it would keep reporting the row at
+      # `1:1` forever, and `--verify-incremental` would keep failing on that project.
+      FORMAT_VERSION = 4
 
       # Payload ABI version. Store values are mostly Marshal blobs of Rigor/RBS objects, so a Rigor release
       # upgrade is an ABI boundary even when the byte layout and descriptor schema are unchanged. Folding the

data/lib/rigor/cli/sig_gen_command.rb

@@ -33,6 +33,12 @@ module Rigor
       VALID_PARAM_POLICIES = %w[untyped observed observed-strict].freeze
       VALID_FORMATS = %w[text json].freeze
 
+      # The skip reasons {#report_skipped} counts. The two left out each have a detailed report of their own
+      # ({#report_unrenderable}, {#report_unresolvable_superclasses}), so a method never shows up in two tallies.
+      SUMMARISED_SKIP_REASONS = (SigGen::Classification::SKIP_DIAGNOSTIC_IDS.keys -
+                                 %i[unrenderable_rbs unresolvable_superclass]).freeze
+      private_constant :SUMMARISED_SKIP_REASONS
+
       # @return [Integer] CLI exit status.
       def run
         options = parse_options
@@ -54,6 +60,7 @@ module Rigor
                    dispatch_print_or_diff(candidates, mode, options)
                    0
                  end
+        report_skipped(candidates, options)
         report_unrenderable(generator.unrenderable)
         report_unresolvable_superclasses(generator.unresolvable_superclasses)
         status
@@ -61,6 +68,28 @@ module Rigor
 
       private
 
+      # Issue #778 — one stderr line per run saying how many methods the generator declined and why, so a
+      # method missing from the output is never a silent absence. Text mode only: under `--format=json` every
+      # skipped row is already in the payload with its `skip_reason`, and stderr stays clean for the consumer.
+      # Per-method lines would be noise at project scale; the JSON payload is where each one is named.
+      def report_skipped(candidates, options)
+        return unless options.fetch(:format) == "text"
+
+        counts = candidates.each_with_object(Hash.new(0)) do |candidate, acc|
+          next unless candidate.classification == SigGen::Classification::SKIPPED
+          next unless SUMMARISED_SKIP_REASONS.include?(candidate.skip_reason)
+
+          acc[candidate.skip_reason] += 1
+        end
+        return if counts.empty?
+
+        breakdown = counts.map { |reason, n| "#{SigGen::Classification::SKIP_DIAGNOSTIC_IDS.fetch(reason)}: #{n}" }
+        @err.puts(
+          "rigor sig-gen: skipped #{counts.values.sum} method(s) it could not type or would not overwrite " \
+          "(#{breakdown.join(', ')}). Run with --format=json to see each one with its skip_reason."
+        )
+      end
+
       # A method whose rendered RBS does not parse is a Rigor rendering defect, not a fact about the user's
       # code — the generator skipped it (so the rest of the signatures are still usable and still valid), but
       # staying silent would leave the user with a quietly incomplete `sig/` and us with an unreported bug.

data/lib/rigor/environment/failure_slot.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Rigor
+  class Environment
+    # Issue #784 — a mutable, first-write-wins record of one shared-build failure, held by the otherwise
+    # frozen {Environment} the way {HktRegistryHolder} holds a memoised value. A lazy build that raises
+    # during per-file analysis records here at its seam instead of raising into every file's
+    # `analyze_body` rescue; the coordinator snapshots the slot after the file loop (the build is lazy, so
+    # a snapshot taken before the loop reads nothing) and the aggregator surfaces it once for the run.
+    #
+    # First-write-wins: the build is memoised, so a second failure can only be the same one re-observed.
+    #
+    # Concurrency: single-threaded use only, the same discipline as {HktRegistryHolder}.
+    class FailureSlot
+      def initialize
+        @value = nil
+      end
+
+      # @param value [Array] a Marshal-clean tuple — the fork pool ships it back from the worker.
+      def record(value)
+        @value = value.freeze if @value.nil?
+      end
+
+      # @return [Array, nil] the recorded tuple, or nil when the build never failed.
+      attr_reader :value
+    end
+  end
+end