rigortype 0.3.9 → 0.4.0

data/plugins/rigor-rails-routes/lib/rigor/plugin/rails_routes/doorkeeper_routes.rb

@@ -63,6 +63,7 @@ module Rigor
             ["oauth_authorized_application_url",  1, "/oauth/authorized_applications/:id", :delete, :destroy]
           ]
         }.freeze
+        Ractor.make_shareable(CONTROLLER_HELPERS)
 
         module_function
 

data/plugins/rigor-rails-routes/lib/rigor/plugin/rails_routes.rb

@@ -192,18 +192,12 @@ module Rigor
         publish_reachability_roots(services, table)
       end
 
-      # File-level only: the once-per-run load-error emission. Per-call helper validation runs over the
-      # engine-owned walk via the node_rule below (ADR-37), with the same-file `shadowing` set built once
-      # as the node-rule file context.
+      # File-level only: the run-scoped load-error disclosure (#1051). Per-call helper validation runs over
+      # the engine-owned walk via the node_rule below (ADR-37), with the same-file `shadowing` set built
+      # once as the node-rule file context.
       def diagnostics_for_file(path:, scope:, root:) # rubocop:disable Lint/UnusedMethodArgument
         table = helper_table_or_nil
-        if table.nil? && @load_error
-          return [] if @load_error_emitted
-
-          @load_error_emitted = true
-          return [load_error_diagnostic(path)]
-        end
-
+        disclose_load_error if table.nil? && @load_error
         []
       end
 
@@ -265,13 +259,11 @@ module Rigor
         nil
       end
 
-      def load_error_diagnostic(path)
-        Rigor::Analysis::Diagnostic.new(
-          path: path, line: 1, column: 1,
-          message: @load_error,
-          severity: :warning,
-          rule: "load-error"
-        )
+      # #1051 — "the routes file did not load" is a fact about the project, not about the file that
+      # happened to be analysed first by this instance, so it goes through the run-scoped channel and the
+      # engine positions it at `.rigor.yml:1:1`, once per run rather than once per fork-pool worker.
+      def disclose_load_error
+        disclose_once(:routes_load_failed, message: @load_error, severity: :warning, rule: "load-error")
       end
     end
 

data/plugins/rigor-rbs-inline/lib/rigor/plugin/rbs_inline/same_line_annotations.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+require "strscan"
+
+module Rigor
+  module Plugin
+    class RbsInline < Base
+      # Issue #998 — the two same-line `%a{}` spellings rbs's built-in `RBS::InlineParser` and Steep's inline
+      # mode accept, repaired into the shape the `rbs-inline` gem's writer honours:
+      #
+      # - `# @rbs %a{…} () -> String` — the gem's `@rbs %a{}` rule lexes the annotations and stops, so the
+      #   method type after them is discarded and the method renders `() -> untyped`;
+      # - `#: %a{…} () -> String` — the gem hands the whole payload to `RBS::Parser.parse_method_type`, which
+      #   has no annotation prefix, so the line becomes a `SyntaxErrorAssertion` and nothing of it survives.
+      #
+      # Both were silent (ADR-32 WD12), and the second reached users as #997's "did not parse … DROPPED"
+      # notice on input that is valid RBS for the other two readers.
+      #
+      # This is a post-parse repair of the gem's annotation list, not a rewrite of the Ruby source. A source
+      # rewrite would have to put the annotation and the method type on two comment lines — the gem has no
+      # one-line spelling for the pair, which is the defect — and inserting a line moves every later line,
+      # including the ones a `#:` notice reports and the one a `def` uses to find its comment block.
+      #
+      # The repair is exact rather than heuristic because every step is the gem's own reading:
+      #
+      # - the leading `%a{…}` spellings are delimited by the gem's own `Tokenizer`, the lexer that already
+      #   accepts them in the own-line form, so what counts as an annotation cannot drift from upstream;
+      # - each half is re-read by the gem's own `AnnotationParser` as the comment the author would have written
+      #   in the own-line form (`# @rbs %a{…}`, then `# @rbs () -> String` or `#: () -> String`), on the same
+      #   line and column, so the replacement annotations are indistinguishable from ones upstream built;
+      # - the split lands only when the remainder re-reads as a well-formed method type. Anything else keeps
+      #   the gem's original annotation untouched, so a genuinely malformed line still reaches the WD12
+      #   notices, and a split can never trade one silent loss for another.
+      module SameLineAnnotations
+        module_function
+
+        # The `@rbs` marker as the gem's `annotation_comment?` detects it, with the whitespace before it.
+        RBS_MARKER = /\A\s*@rbs\b/
+
+        # Replaces, in `parsing_result.annotations`, every same-line form that splits cleanly with the
+        # annotation and the method type it spells. Idempotent: a repaired list has no same-line form left.
+        def split!(parsing_result)
+          return parsing_result unless parsing_result.is_a?(::RBS::Inline::AnnotationParser::ParsingResult)
+
+          parsing_result.annotations.replace(parsing_result.annotations.flat_map { |annotation| expand(annotation) })
+          parsing_result
+        end
+
+        # Every `ParsingResult` a parsed declaration tree holds, which are the objects the writer reads.
+        def each_parsing_result(nodes, &)
+          nodes.each do |node|
+            comments = node.respond_to?(:comments) ? node.comments : nil
+            yield comments if comments.is_a?(::RBS::Inline::AnnotationParser::ParsingResult)
+            each_parsing_result(node.members, &) if node.respond_to?(:members)
+          end
+        end
+
+        # The text an `@rbs %a{…}` line carries after its annotations that the gem discarded — `nil` when
+        # there is none. Call it on an annotation {.split!} has already seen: a remainder that survives the
+        # split is one that did not read as a method type.
+        def dropped_remainder(annotation)
+          return nil unless annotation.is_a?(::RBS::Inline::AST::Annotations::RBSAnnotation)
+
+          parts = same_line_parts(annotation)
+          parts && parts[2].strip
+        end
+
+        def expand(annotation)
+          parts = same_line_parts(annotation)
+          return [annotation] if parts.nil?
+
+          prefix, spellings, rest = parts
+          method_type = reparse(annotation, "##{prefix}#{rest}")
+          return [annotation] unless well_formed_method_type?(method_type)
+
+          # Re-read even when `annotation` already is the `@rbs %a{}` carrier: the original still spans the
+          # method type in its source, and {.dropped_remainder} reads exactly that to report a failed split.
+          carrier = reparse(annotation, "# @rbs #{spellings.join(' ')}")
+          return [annotation] unless carrier.is_a?(::RBS::Inline::AST::Annotations::RBSAnnotation)
+
+          [carrier, method_type]
+        end
+
+        # `[prefix, spellings, rest]` for an annotation whose payload opens with one or more `%a{…}` and
+        # continues with something else, or `nil`. `prefix` is the marker as written (`" @rbs"` or `":"`),
+        # so the re-read keeps the gem's continuation offset for a multi-line comment block.
+        def same_line_parts(annotation)
+          # `annotations` also holds the `CommentLines` of plain prose, which has no `source` to read.
+          prefix =
+            case annotation
+            when ::RBS::Inline::AST::Annotations::RBSAnnotation
+              annotation.source.string[RBS_MARKER]
+            when ::RBS::Inline::AST::Annotations::SyntaxErrorAssertion
+              ":" if annotation.source.string.start_with?(":")
+            end
+          return nil if prefix.nil?
+
+          spellings, rest = leading_annotations(annotation.source.string.delete_prefix(prefix))
+          return nil if spellings.empty? || rest.strip.empty?
+
+          [prefix, spellings, rest]
+        end
+
+        # The `%a{…}` tokens the gem's tokenizer reads at the head of `body`, and the unread text after them.
+        def leading_annotations(body)
+          tokenizer = ::RBS::Inline::AnnotationParser::Tokenizer.new(StringScanner.new(body))
+          trivia = ::RBS::Inline::AST::Tree.new(:rigor_same_line_annotations)
+          tokenizer.advance(trivia)
+          tokenizer.advance(trivia)
+
+          spellings = []
+          while tokenizer.type?(::RBS::Inline::AnnotationParser::Tokens::T_ANNOTATION)
+            spellings << tokenizer.lookahead1[1]
+            tokenizer.advance(trivia)
+          end
+          [spellings, tokenizer.rest]
+        end
+
+        # Reads `comment_text` through the gem's `AnnotationParser` as if it stood where `annotation`'s comment
+        # block does — same first line, same column, continuation lines re-prefixed with the `#` that
+        # `CommentLines#string` strips — and returns the one annotation it yields, or `nil`.
+        def reparse(annotation, comment_text)
+          location = annotation.source.comments.first&.location
+          return nil if location.nil?
+
+          indent = " " * location.start_column
+          padding = "\n" * (location.start_line - 1)
+          source = "#{padding}#{indent}#{comment_text.gsub("\n") { "\n#{indent}#" }}\n"
+          results = ::RBS::Inline::AnnotationParser.parse(::Prism.parse(source).comments)
+          return nil unless results.size == 1
+
+          annotations = results.first.annotations
+          annotations.size == 1 && annotations.first.is_a?(::RBS::Inline::AST::Annotations::Base) ? annotations.first : nil
+        end
+
+        def well_formed_method_type?(annotation)
+          case annotation
+          when ::RBS::Inline::AST::Annotations::MethodTypeAssertion
+            true
+          when ::RBS::Inline::AST::Annotations::Method
+            annotation.method_types.is_a?(Array) && annotation.error_source.nil?
+          else
+            false
+          end
+        end
+      end
+    end
+  end
+end

data/plugins/rigor-rbs-inline/lib/rigor/plugin/rbs_inline.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "rigor/plugin"
+require_relative "rbs_inline/same_line_annotations"
 
 # ADR-32 — bundled `rigor-rbs-inline` plugin.
 #
@@ -68,6 +69,18 @@ module Rigor
         # instead of adopting the placeholder. `Rigor::RbsExtended.inferred_return?` is the reader.
         INFERRED_RETURN_ANNOTATION = "rigor:v1:inferred-return"
 
+        # The RBS annotation the synthesizer writes on every member where upstream defaulted EVERY type
+        # slot — every parameter and the return alike — because the author's comment block asserted nothing
+        # about this member's own contract (issue #991). This is a strictly narrower condition than
+        # {INFERRED_RETURN_ANNOTATION}: that one fires whenever the return alone defaulted, which is also
+        # true of a member whose parameters WERE annotated (`# @rbs num: Float` with no `# @rbs return:`).
+        # This annotation distinguishes "nobody said anything about this member" from "the return half was
+        # left to inference" — the two collapse under return-only provenance, because no equivalent
+        # per-parameter survivor exists to separate them (see {DEFAULTED_TYPE_NAME}), so this constant
+        # exists precisely to carry that missing half. Its meaning is normative in
+        # `docs/type-specification/rbs-extended.md`. `Rigor::RbsExtended.inferred_signature?` is the reader.
+        INFERRED_SIGNATURE_ANNOTATION = "rigor:v1:inferred-signature"
+
         # The stand-in type handed to upstream's `Writer#default_type`, and the whole reason this plugin can
         # tell a defaulted type from an authored one. `RBS::Inline::Writer` substitutes `default_type`
         # wherever the author wrote nothing — `return_type || default_type` in `RubyDef#method_overloads`,
@@ -119,6 +132,9 @@ module Rigor
           return nil if parsed.nil?
 
           uses, decls, rbs_decls = parsed
+          # Issue #998 — before the writer reads the annotation lists, so a same-line `%a{…} () -> T` renders
+          # with its method type and its annotation both attached. See {SameLineAnnotations}.
+          SameLineAnnotations.each_parsing_result(decls) { |comments| SameLineAnnotations.split!(comments) }
           rendered = mark_inferred_returns(render_with_defaulted_marker(uses, decls, rbs_decls))
           rendered = reattach_declaration_annotations(rendered)
           return nil if rendered.nil? || rendered.strip.empty?
@@ -162,6 +178,15 @@ module Rigor
         # about the return. The engine reads the annotation in `RbsDispatch` and falls through to the same
         # body-inference tier an undeclared method takes.
         #
+        # A member additionally carries {INFERRED_SIGNATURE_ANNOTATION} when EVERY type slot on it —
+        # not only the return — defaulted: a fully bare `def`, or one whose only annotation lives on a
+        # sibling member the file also happens to carry. A member with a parameter annotated (`# @rbs num:
+        # Float`) but no `# @rbs return:` still gets {INFERRED_RETURN_ANNOTATION} (the return did default),
+        # but NOT this one — the author asserted something about the member, just not its return. Issue
+        # #991's `call.wrong-arity` reads this one rather than the return-only annotation, because the
+        # arity question is about the parameter list, and the parameter list is exactly what tells the two
+        # cases apart.
+        #
         # Two properties make the rewrite safe rather than clever:
         #
         # - the stand-in is a token this plugin injected, so replacing it is exact — it can only appear
@@ -181,53 +206,85 @@ module Rigor
         def mark_inferred_returns(rendered)
           return rendered if rendered.nil? || !rendered.b.include?(DEFAULTED_TYPE_NAME.to_s)
 
-          marked_lines = rendered.valid_encoding? ? defaulted_member_lines(rendered) : Set.new
+          return_lines, signature_lines =
+            rendered.valid_encoding? ? defaulted_member_lines(rendered) : [Set.new, Set.new]
           scrubbed = rendered.b.gsub(DEFAULTED_TYPE_NAME.to_s, "untyped").force_encoding(rendered.encoding)
-          return scrubbed if marked_lines.empty?
+          return scrubbed if return_lines.empty?
 
           scrubbed.lines.each_with_index.flat_map do |line, index|
-            next line unless marked_lines.include?(index + 1)
+            line_number = index + 1
+            next line unless return_lines.include?(line_number)
 
-            ["#{line[/\A[ \t]*/]}%a{#{INFERRED_RETURN_ANNOTATION}}\n", line]
+            indent = line[/\A[ \t]*/]
+            annotations = ["#{indent}%a{#{INFERRED_RETURN_ANNOTATION}}\n"]
+            annotations << "#{indent}%a{#{INFERRED_SIGNATURE_ANNOTATION}}\n" if signature_lines.include?(line_number)
+            [*annotations, line]
           end.join
         end
 
-        # The 1-based line of every member in `rendered` whose return type (or, for an attribute, whose
-        # type) is the defaulted stand-in. A member's `location.start_line` is the line its `def` /
-        # `attr_*` keyword sits on, which is where the annotation has to go.
+        # The 1-based lines of every member in `rendered` whose return type (or, for an attribute, whose
+        # type) is the defaulted stand-in — and, of those, the subset where EVERY type slot on the member
+        # defaulted, not only the return. A member's `location.start_line` is the line its `def` /
+        # `attr_*` keyword sits on, which is where the annotation has to go. Returns `[return_lines,
+        # signature_lines]`; `signature_lines` is always a subset of `return_lines`, since a member cannot
+        # have every slot defaulted without its return being one of them.
         def defaulted_member_lines(rendered)
           buffer = ::RBS::Buffer.new(name: "(rigor: inline defaulted-type probe)", content: rendered)
           _, _directives, decls = ::RBS::Parser.parse_signature(buffer)
-          collect_defaulted_member_lines(decls, Set.new)
+          collect_defaulted_member_lines(decls, Set.new, Set.new)
         rescue ::StandardError
           # The writer's own output failing to parse is a condition the loader already handles (ADR-32 WD6
           # fail-soft drops the entry). Declining to mark here keeps that the only failure.
-          Set.new
+          [Set.new, Set.new]
         end
 
-        def collect_defaulted_member_lines(nodes, lines)
+        def collect_defaulted_member_lines(nodes, return_lines, signature_lines)
           nodes.each do |node|
             next unless node.respond_to?(:members)
 
             node.members.each do |member|
-              line = defaulted_member_line(member)
-              lines << line if line
+              classify_defaulted_member(member, return_lines, signature_lines)
             end
-            collect_defaulted_member_lines(node.members.grep(::RBS::AST::Declarations::Base), lines)
+            collect_defaulted_member_lines(
+              node.members.grep(::RBS::AST::Declarations::Base), return_lines, signature_lines
+            )
           end
-          lines
+          [return_lines, signature_lines]
         end
 
-        def defaulted_member_line(member)
+        def classify_defaulted_member(member, return_lines, signature_lines)
           case member
           when ::RBS::AST::Members::MethodDefinition
-            return nil unless member.overloads.any? { |o| defaulted_type?(o.method_type.type.return_type) }
+            return unless member.overloads.any? { |o| defaulted_type?(o.method_type.type.return_type) }
+
+            line = member.location&.start_line
+            return if line.nil?
+
+            return_lines << line
+            signature_lines << line if member.overloads.all? { |o| fully_defaulted_overload?(o) }
           when ::RBS::AST::Members::Attribute
-            return nil unless defaulted_type?(member.type)
-          else
-            return nil
+            return unless defaulted_type?(member.type)
+
+            line = member.location&.start_line
+            return if line.nil?
+
+            # An attribute has exactly one type slot (the value type, shared by its reader and writer
+            # overloads), so "the type defaulted" and "every type slot defaulted" are the same fact.
+            return_lines << line
+            signature_lines << line
           end
-          member.location&.start_line
+        end
+
+        # True when every parameter type and the return type of `overload` — everything
+        # `RBS::Types::Function#each_type` yields — is the defaulted stand-in, i.e. the author's comment
+        # block asserted nothing about this overload's own contract. Block-type provenance is
+        # deliberately not part of this: a block parameter's shape does not bear on the positional arity
+        # #991 exists to check, and upstream defaults it independently of the parameter list either way.
+        def fully_defaulted_overload?(overload)
+          function = overload.method_type.type
+          return false unless function.respond_to?(:each_type)
+
+          function.each_type.all? { |type| defaulted_type?(type) }
         end
 
         def defaulted_type?(type)
@@ -300,29 +357,153 @@ module Rigor
         # These are invisible without a report: synthesis succeeds, and the annotation comment is even echoed
         # into the generated RBS, so the omission shows up neither in the output nor at runtime.
         #
-        # The one case today is `module-self`, where the two inline-RBS dialects disagree on spelling. rbs's
-        # own `docs/inline.md` documents `# @rbs module-self: Foo`; the rbs-inline gem's grammar is
-        # `# @rbs module-self Foo`, without the colon. Handed the colon form the gem still builds a
-        # `ModuleSelf` annotation but extracts no types from it, so an empty `self_types` on a parsed
-        # annotation is a precise signature for "the author asked for a constraint we did not apply".
-        # Measured both ways in `docs/notes/20260730-inline-rbs-parser-grammar-diff.md`.
+        # Five cases today:
+        #
+        # - `module-self`, where the two inline-RBS dialects disagree on spelling. rbs's own `docs/inline.md`
+        #   documents `# @rbs module-self: Foo`; the rbs-inline gem's grammar is `# @rbs module-self Foo`,
+        #   without the colon. Handed the colon form the gem still builds a `ModuleSelf` annotation but
+        #   extracts no types from it, so an empty `self_types` on a parsed annotation is a precise signature
+        #   for "the author asked for a constraint we did not apply". Measured both ways in
+        #   `docs/notes/20260730-inline-rbs-parser-grammar-diff.md`.
+        # - a `#:` line whose type does not parse (issue #997). Upstream's own tolerant parse
+        #   ({#parse_type_method_type} in its `annotation_parser.rb`) never raises on this: it consumes the
+        #   rest of the line into a `SyntaxErrorAssertion` and moves on, so nothing upstream ever surfaces
+        #   the failure. Measured at 568138c2: `#: (finite-float) -> String` above a `def` synthesized no
+        #   signature for it AT ALL, and `rigor check` on the file reported nothing beyond an unrelated
+        #   `rbs.coverage.missing-gem` info — the annotation was indistinguishable from one never written,
+        #   which ADR-93's "an inline annotation is a live contract" forbids.
+        # - an `# @rbs %a{…}` line whose text after the annotations is not a method type (issue #998). The
+        #   gem's `@rbs %a{}` rule lexes the annotations and ignores the rest of the line, so
+        #   `# @rbs %a{pure} (finite-float) -> String` keeps `%a{pure}` and discards the signature beside it
+        #   without a word. A remainder that IS a method type is not reported, because
+        #   {SameLineAnnotations.split!} has already made it bind — the notice is for what that repair
+        #   could not read.
+        # - an `# @rbs name: T` parameter (or local-variable) annotation whose `T` does not parse (issue
+        #   #1019, row H). The gem's grammar makes the colon-and-type optional — {#parse_var_decl} always
+        #   builds a `VarType`, even when `parse_type` fell through — so a malformed type leaves `name`
+        #   present and `type` `nil` rather than raising: `# @rbs n: Integer[1..10]` names `n` and leaves its
+        #   type unset. `Writer#default_type` then fills the empty slot the same way an UNANNOTATED parameter
+        #   is filled, so `VarType#type.nil?` is indistinguishable downstream from "the author wrote nothing"
+        #   without this check — the same silent-drop shape #997 closed for `#:` lines and `return:`, now
+        #   closed for `name:`.
+        # - an `@rbs`-prefixed comment paragraph whose body is not one of the gem's known annotation shapes
+        #   (issue #1019, row B). {RBS::Inline::AnnotationParser#annotation_comment?} matches a `\b` word
+        #   boundary right after `@rbs`, so `# @rbs-ext …` is inside its net — the gem treats it as an `@rbs`
+        #   annotation attempt — but {RBS::Inline::AnnotationParser#parse_annotation}'s `case` has no branch
+        #   for what follows `-ext`, falls through with no `else`, and returns `nil`. `AnnotationParser#parse`
+        #   then folds the whole paragraph back into a `CommentLines` — the SAME class an ordinary comment
+        #   parses to — so nothing distinguishes "the gem tried to read this as `@rbs` and failed" from
+        #   "this was never meant to be one" except the marker the gem itself keyed on. {SameLineAnnotations::
+        #   RBS_MARKER} already carries that exact marker (documented there as "the `@rbs` marker as the
+        #   gem's `annotation_comment?` detects it"), reused here rather than duplicated, so a `CommentLines`
+        #   paragraph is only reported when the gem's own detector would have called it an `@rbs` attempt.
+        #
+        # The list is repaired by {SameLineAnnotations.split!} first, exactly as the synthesis path repairs
+        # its own, so a valid same-line `#: %a{…} () -> T` is not reported as a `#:` line that failed to
+        # parse: it did not fail, it binds.
         #
-        # Deliberately narrow. A construct the gem's parser REJECTS already routes through WD6's error path,
-        # and one it never recognised at all is upstream's grammar to define (WD3) — guessing at those would
-        # make this a lint on comment prose, which is exactly the false-positive cost ADR-5 ranks first.
+        # Deliberately narrow otherwise. A construct the gem's parser REJECTS already routes through WD6's
+        # error path, and one it never recognised at all is upstream's grammar to define (WD3) — guessing at
+        # those would make this a lint on comment prose, which is exactly the false-positive cost ADR-5 ranks
+        # first. `SyntaxErrorAssertion` is neither: the gem's OWN parser recognised the `#:` shape and
+        # positively flagged its payload as unparseable, so reporting it is naming a fact rbs-inline already
+        # computed, not guessing at one. The row-B check is the same kind of fact, read off the gem's own
+        # marker rather than a fact rbs-inline names with a dedicated AST class — nothing else in the grammar
+        # collapses a recognised-but-unparseable paragraph into ordinary prose.
         def unhonoured_annotations(prism_result)
           ::RBS::Inline::AnnotationParser.parse(prism_result.comments).flat_map do |parsed|
-            parsed.each_annotation.filter_map do |annotation|
-              next unless annotation.is_a?(::RBS::Inline::AST::Annotations::ModuleSelf)
-              next unless annotation.self_types.empty?
-
-              "`@rbs module-self` contributed no self-type constraint. Rigor reads the " \
-                "`# @rbs module-self Foo` spelling; `# @rbs module-self: Foo` (the spelling in rbs's own " \
-                "inline documentation) is not honoured here."
+            repaired = SameLineAnnotations.split!(parsed)
+            unrecognised_tag_notices(repaired) + repaired.each_annotation.filter_map do |annotation|
+              case annotation
+              when ::RBS::Inline::AST::Annotations::ModuleSelf
+                next if annotation.self_types.any?
+
+                "`@rbs module-self` contributed no self-type constraint. Rigor reads the " \
+                  "`# @rbs module-self Foo` spelling; `# @rbs module-self: Foo` (the spelling in rbs's own " \
+                  "inline documentation) is not honoured here."
+              when ::RBS::Inline::AST::Annotations::SyntaxErrorAssertion
+                syntax_error_assertion_notice(annotation)
+              when ::RBS::Inline::AST::Annotations::RBSAnnotation
+                dropped_remainder_notice(annotation)
+              when ::RBS::Inline::AST::Annotations::VarType
+                var_type_notice(annotation)
+              end
             end
           end.uniq
         end
 
+        # Issue #997 — the line comes off the annotation's OWN `Prism::Comment` location, not the
+        # synthesized RBS buffer: unlike {Environment::RbsLoader#unresolved_type_name_detail}'s position,
+        # this one is read straight from the `.rb` file this synthesis call is fresh over (the per-file
+        # synthesizer cache is content-keyed, so a changed file simply misses rather than replaying a stale
+        # line), so it is the real line the author wrote, not an approximation.
+        def syntax_error_assertion_notice(annotation)
+          line = annotation.source.comments.first&.location&.start_line
+          position = line ? " on line #{line}" : ""
+          "a `#:` annotation#{position} did not parse as an RBS method type or type " \
+            "(`#{annotation.error_string}`) and was DROPPED — the method types as if the annotation had " \
+            "never been written, not merely as if its type were wrong. Fix the RBS syntax to restore it."
+        end
+
+        # Issue #998 — the line is read off the annotation's own comment, as in {#syntax_error_assertion_notice}.
+        def dropped_remainder_notice(annotation)
+          remainder = SameLineAnnotations.dropped_remainder(annotation)
+          return nil if remainder.nil?
+
+          line = annotation.source.comments.first&.location&.start_line
+          position = line ? " on line #{line}" : ""
+          "the text after the `%a{…}` annotation#{position} (`#{remainder}`) did not parse as an RBS method " \
+            "type and was DROPPED — the annotation is kept, but the method types as if no signature had been " \
+            "written beside it. Fix the RBS syntax to restore it."
+        end
+
+        # Issue #1019, row H — a `# @rbs name: T` whose `T` the gem's `parse_type` could not build, read off
+        # {RBS::Inline::AST::Annotations::VarType#type} being `nil` rather than off any pattern over the
+        # comment text. Silent otherwise: {Writer#default_type} fills the slot exactly as it fills a
+        # parameter nobody annotated, so `(untyped n)` does not distinguish "wrote nothing" from "wrote a
+        # type RBS could not parse". `raw` is `nil` (and the notice withheld) for the colon-less `# @rbs
+        # name` shorthand — the grammar accepts it too, but with no text to name as the dropped type it is a
+        # bare mention, not a failed assertion.
+        def var_type_notice(annotation)
+          return nil if annotation.type
+
+          raw = annotation.source.string[/#{Regexp.escape(annotation.name.to_s)}\s*:\s*(.+)\z/, 1]&.strip
+          return nil if raw.nil? || raw.empty?
+
+          line = annotation.source.comments.first&.location&.start_line
+          position = line ? " on line #{line}" : ""
+          "a `# @rbs #{annotation.name}:` annotation#{position} (`#{raw}`) did not parse as an RBS type " \
+            "and was DROPPED — the parameter types as `untyped`, not merely as if its type were wrong. If " \
+            "`#{raw}` is a Rigor refinement, write it as an `%a{rigor:v1:param: #{annotation.name} is " \
+            "#{raw}}` annotation beside the plain RBS type instead — see " \
+            "docs/manual/16-rbs-extended-annotations.md — to restore type coverage."
+        end
+
+        # Issue #1019, row B — an `@rbs`-prefixed comment paragraph the gem's OWN detector
+        # ({RBS::Inline::AnnotationParser#annotation_comment?}) called an `@rbs` annotation attempt, that
+        # `#parse_annotation`'s `case` had no branch for. `# @rbs-ext return: non-empty-string` is the case
+        # in point: `annotation_comment?`'s `/\A#(\s*)@rbs(\b|!)/` matches the `\b` word boundary between
+        # `s` and `-`, so the gem tries to read it as `@rbs`, fails, and folds it back into a `CommentLines`
+        # — the same class a `# rigor: …` or `# @extrbs …` paragraph parses to, which never claimed to be
+        # `@rbs` and must stay silent (row X / row C). {SameLineAnnotations::RBS_MARKER} already carries the
+        # gem's own marker, so matching it here is reading the SAME fact the gem's detector computed, not
+        # inventing a new one — see {#unhonoured_annotations}'s row-B paragraph for why that is not the
+        # "regexp lint on comment prose" WD12 otherwise declines to run.
+        def unrecognised_tag_notices(parsing_result)
+          parsing_result.annotations.grep(::RBS::Inline::AST::CommentLines).filter_map do |lines|
+            first_line = lines.string.each_line.first.to_s.strip
+            next unless SameLineAnnotations::RBS_MARKER.match?(first_line)
+
+            line = lines.comments.first&.location&.start_line
+            position = line ? " on line #{line}" : ""
+            "a comment#{position} (`##{first_line}`) opens with the `@rbs` marker but its body did not " \
+              "parse as a recognised `@rbs` annotation, so the whole line was DROPPED — this is not a " \
+              "recognised tag, and nothing on it was applied. Use one of the documented `# @rbs` forms " \
+              "(`name: T`, `return: T`, `module-self T`, …), or rename the tag so it does not start with " \
+              "`@rbs`, to avoid this notice."
+          end
+        end
+
         # Rewrite every RDoc directive comment to its spaced spelling (`#:nodoc:` -> `# :nodoc:`) so
         # upstream's annotation grammar never sees it, and re-parse. Two reasons this happens here rather
         # than in {#annotated?}: the directive must not gate a file in, AND it must not reach the synthesis,

data/plugins/rigor-sidekiq/lib/rigor/plugin/sidekiq/schedule_scan.rb

@@ -41,6 +41,7 @@ module Rigor
         # `schedule.yml` IS the schedule map — and the nested paths are `sidekiq-scheduler`'s, whose entries
         # live under `:scheduler: :schedule:` (with the bare `:schedule:` form kept for pre-3.0 layouts).
         SCHEDULE_BLOCK_KEY_PATHS = [[], %w[scheduler schedule], %w[schedule]].freeze
+        Ractor.make_shareable(SCHEDULE_BLOCK_KEY_PATHS)
 
         # Errno classes that mean "this path is not readable as a schedule" — swallowed so one bad path does
         # not cost the roots the other paths supply.

data/plugins/rigor-sidekiq/lib/rigor/plugin/sidekiq.rb

@@ -137,12 +137,12 @@ module Rigor
         services.fact_store.publish(plugin_id: manifest.id, name: :reachability_roots, value: roots)
       end
 
-      # File-level only: the load-error emission. The per-call arity validation runs over the engine-owned
+      # File-level only: the load-error disclosure. The per-call arity validation runs over the engine-owned
       # walk via the node_rule below (ADR-37). The worker index is lazily loaded + memoised by
       # `producer_value`, shared by both surfaces.
       def diagnostics_for_file(path:, scope:, root:) # rubocop:disable Lint/UnusedMethodArgument
         index = producer_value(:worker_index)
-        return [load_error_diagnostic(path)] if index.nil? && producer_error(:worker_index)
+        disclose_load_error if index.nil? && producer_error(:worker_index)
 
         []
       end
@@ -206,10 +206,14 @@ module Rigor
 
       private
 
-      def load_error_diagnostic(path)
+      # Issue #1056 — "the worker index did not load" is a fact about the run's INPUTS, not about the file being
+      # analysed, so it is registered rather than returned: see {Plugin::Base#disclose_once} for the
+      # channel, the `(plugin id, key)` de-duplication and why the engine positions it at `.rigor.yml:1:1`.
+      # Returned from the per-file hook it carried no once-guard at all and repeated on every file.
+      def disclose_load_error
         error = producer_error(:worker_index)
-        Rigor::Analysis::Diagnostic.new(
-          path: path, line: 1, column: 1,
+        disclose_once(
+          :worker_index_load_failed,
           message: "rigor-sidekiq: failed to discover workers: #{error.class}: #{error.message}",
           severity: :warning,
           rule: "load-error"

data/plugins/rigor-sorbet/lib/rigor/plugin/sorbet/sigil_detector.rb

@@ -30,7 +30,6 @@ module Rigor
 
         module_function
 
-        # @param contents — raw file contents.
         # @return one of {VALID_LEVELS}; defaults to {DEFAULT_LEVEL} for sigil-less or
         #   malformed-sigil files.
         def detect(contents)