rigortype 0.2.7 → 0.2.8

data/lib/rigor/analysis/dependency_source_inference/walker.rb

@@ -8,82 +8,61 @@ require_relative "../../source/constant_path"
 module Rigor
   module Analysis
     module DependencySourceInference
-      # Walks a resolved gem's `roots:` and collects the
-      # `(class_name, method_name) → CatalogEntry(kind,
-      # return_type)` method catalog. The walker is the source
-      # of facts the dispatcher tier consults to recognise a
-      # method as defined by an opt-in gem and contribute a
-      # `Type::Dynamic`-wrapped return at the call site.
+      # Walks a resolved gem's `roots:` and collects the `(class_name, method_name) → CatalogEntry(kind,
+      # return_type)` method catalog. The walker is the source of facts the dispatcher tier consults to
+      # recognise a method as defined by an opt-in gem and contribute a `Type::Dynamic`-wrapped return at
+      # the call site.
       #
-      # The dispatcher tier wraps every walker-contributed return
-      # in `Dynamic[T]` per ADR-10's gem-boundary contract. When
-      # the heuristic ({ReturnTypeHeuristic}) recognises the
-      # method body's tail expression, the dispatcher uses the
-      # heuristic's static facet; otherwise it falls back to
-      # `Dynamic[top]` (the pre-heuristic behaviour). The
-      # heuristic is intentionally narrow — only literal-tail
-      # method bodies fold; everything else degrades silently.
+      # The dispatcher tier wraps every walker-contributed return in `Dynamic[T]` per ADR-10's gem-boundary
+      # contract. When the heuristic ({ReturnTypeHeuristic}) recognises the method body's tail expression,
+      # the dispatcher uses the heuristic's static facet; otherwise it falls back to `Dynamic[top]` (the
+      # pre-heuristic behaviour). The heuristic is intentionally narrow — only literal-tail method bodies
+      # fold; everything else degrades silently.
       #
-      # Hard exclusions are NOT user-configurable, per ADR-10
-      # § "Hard exclusions": top-level `spec/`, `test/`, `bin/`,
-      # plus any non-`.rb` source. C extensions fall out
-      # automatically because the walker only loads `.rb` files.
+      # Hard exclusions are NOT user-configurable, per ADR-10 § "Hard exclusions": top-level `spec/`,
+      # `test/`, `bin/`, plus any non-`.rb` source. C extensions fall out automatically because the walker
+      # only loads `.rb` files.
       module Walker
-        # Top-level directories that MUST NOT participate in
-        # gem-source inference even when the user lists them
-        # under `roots:`. The check is case-insensitive against
-        # the first segment of `roots:`; nested `spec/` /
-        # `test/` directories deeper inside `lib/` are NOT
-        # filtered (a few gems legitimately ship `lib/.../spec/`).
+        # Top-level directories that MUST NOT participate in gem-source inference even when the user lists
+        # them under `roots:`. The check is case-insensitive against the first segment of `roots:`; nested
+        # `spec/` / `test/` directories deeper inside `lib/` are NOT filtered (a few gems legitimately ship
+        # `lib/.../spec/`).
         HARD_EXCLUDED_ROOTS = %w[spec test bin].freeze
 
-        # Walker outcome wrapping the harvested method catalog
-        # plus a budget-exceeded flag. ADR-10 slice 4 introduces
-        # the cap; the Walker stops appending to the accumulator
-        # once `catalog.size` reaches `budget`, and `truncated?`
-        # reports whether the cap was reached. The Index records
-        # this per-gem so the Runner can surface a single
-        # `dynamic.dependency-source.budget-exceeded` warning
-        # naming the affected gem(s).
+        # Walker outcome wrapping the harvested method catalog plus a budget-exceeded flag. ADR-10 slice 4
+        # introduces the cap; the Walker stops appending to the accumulator once `catalog.size` reaches
+        # `budget`, and `truncated?` reports whether the cap was reached. The Index records this per-gem so
+        # the Runner can surface a single `dynamic.dependency-source.budget-exceeded` warning naming the
+        # affected gem(s).
         class Outcome < Data.define(:catalog, :truncated)
           def truncated? = truncated
         end
 
-        # Per-method catalog entry. `kind` is `:instance` or
-        # `:singleton`; `return_type` is the
-        # {ReturnTypeHeuristic}-extracted static facet (a
-        # `Rigor::Type::*`) or `nil` when the heuristic declined.
-        # The dispatcher wraps a non-nil `return_type` in
-        # `Dynamic[T]`; a `nil` `return_type` falls back to
-        # `Dynamic[top]`.
+        # Per-method catalog entry. `kind` is `:instance` or `:singleton`; `return_type` is the
+        # {ReturnTypeHeuristic}-extracted static facet (a `Rigor::Type::*`) or `nil` when the heuristic
+        # declined. The dispatcher wraps a non-nil `return_type` in `Dynamic[T]`; a `nil` `return_type` falls
+        # back to `Dynamic[top]`.
         class CatalogEntry < Data.define(:kind, :return_type)
           def initialize(kind:, return_type: nil)
             super
           end
         end
 
-        # Sentinel for "no cap" — used by callers that don't
-        # care about the budget (specs, tooling). Production
-        # code MUST pass an integer.
+        # Sentinel for "no cap" — used by callers that don't care about the budget (specs, tooling).
+        # Production code MUST pass an integer.
         UNBOUNDED = Float::INFINITY
 
         module_function
 
-        # @param gem_dir [String, Pathname] absolute path to the
-        #   gem's installation directory.
-        # @param roots [Array<String>] subdirectory names within
-        #   the gem to walk (defaults to `["lib"]` per
+        # @param gem_dir [String, Pathname] absolute path to the gem's installation directory.
+        # @param roots [Array<String>] subdirectory names within the gem to walk (defaults to `["lib"]` per
         #   `Configuration::Dependencies::Entry`).
-        # @param budget [Integer, Float] per-gem catalog cap
-        #   (method-definition count). When unset, defaults to
-        #   `UNBOUNDED` for backwards-compatible test paths.
-        # @return [Outcome] frozen wrapper carrying the catalog
-        #   (`Hash{[class_name, method_name] => :instance |
-        #   :singleton}`) and a `truncated?` flag set when the
-        #   walker stopped harvesting because the budget was
-        #   reached. Methods of identical name on the same class
-        #   with different kinds (rare; private API mostly)
-        #   carry the kind that wins the per-class first walk.
+        # @param budget [Integer, Float] per-gem catalog cap (method-definition count). When unset, defaults
+        #   to `UNBOUNDED` for backwards-compatible test paths.
+        # @return [Outcome] frozen wrapper carrying the catalog (`Hash{[class_name, method_name] =>
+        #   :instance | :singleton}`) and a `truncated?` flag set when the walker stopped harvesting because
+        #   the budget was reached. Methods of identical name on the same class with different kinds (rare;
+        #   private API mostly) carry the kind that wins the per-class first walk.
         def walk(gem_dir:, roots:, budget: UNBOUNDED)
           accumulator = {}
           truncated = false
@@ -95,18 +74,14 @@ module Rigor
           Outcome.new(catalog: accumulator.freeze, truncated: truncated)
         end
 
-        # Drops hard-excluded entries before any filesystem
-        # walk happens. Reasoning: we never want a gem's
-        # `spec/` to participate even if the user requested
-        # it — the noise from RSpec-style globals plus the
-        # cost of walking test fixtures isn't worth the
-        # marginal coverage.
+        # Drops hard-excluded entries before any filesystem walk happens. Reasoning: we never want a gem's
+        # `spec/` to participate even if the user requested it — the noise from RSpec-style globals plus
+        # the cost of walking test fixtures isn't worth the marginal coverage.
         def accepted_roots(roots)
           roots.reject { |root| HARD_EXCLUDED_ROOTS.include?(root.downcase) }
         end
 
-        # Returns true when the budget tripped during this
-        # root's walk so the caller can stop iterating
+        # Returns true when the budget tripped during this root's walk so the caller can stop iterating
         # subsequent roots.
         def walk_root(root_dir, accumulator, budget) # rubocop:disable Naming/PredicateMethod
           return false unless File.directory?(root_dir)
@@ -124,19 +99,15 @@ module Rigor
 
           walk_node(parse_result.value, [], false, accumulator, budget)
         rescue StandardError
-          # Gem source we can't parse / read silently degrades
-          # to "no contribution from this file". The user-facing
-          # diagnostic stream is reserved for the project source;
-          # opt-in gem source MUST NOT pollute it with parse
-          # errors the user cannot fix.
+          # Gem source we can't parse / read silently degrades to "no contribution from this file". The
+          # user-facing diagnostic stream is reserved for the project source; opt-in gem source MUST NOT
+          # pollute it with parse errors the user cannot fix.
           nil
         end
 
-        # Walks a Prism subtree, accumulating method definitions
-        # under their qualified class name. Mirrors the shape of
-        # `Inference::ScopeIndexer#walk_methods` but stays
-        # decoupled from `Scope` because gem-source inference
-        # runs without a scope context.
+        # Walks a Prism subtree, accumulating method definitions under their qualified class name. Mirrors
+        # the shape of `Inference::ScopeIndexer#walk_methods` but stays decoupled from `Scope` because
+        # gem-source inference runs without a scope context.
         def walk_node(node, qualified_prefix, in_singleton_class, accumulator, budget)
           return unless node.is_a?(Prism::Node)
           return if accumulator.size >= budget
@@ -161,11 +132,9 @@ module Rigor
           end
         end
 
-        # `class Foo` / `module Bar`. The dynamic-prefix shape
-        # (`module ::Foo`-rooted variants whose left side is a
-        # runtime expression) is treated as opaque — we walk the
-        # children under the same prefix so any inner class
-        # definitions are still recorded under their own name.
+        # `class Foo` / `module Bar`. The dynamic-prefix shape (`module ::Foo`-rooted variants whose left
+        # side is a runtime expression) is treated as opaque — we walk the children under the same prefix
+        # so any inner class definitions are still recorded under their own name.
         def descend_class_or_module(node, qualified_prefix, in_singleton_class, accumulator, budget)
           name = Source::ConstantPath.qualified_name_or_nil(node.constant_path)
           if name && node.body
@@ -175,10 +144,8 @@ module Rigor
           end
         end
 
-        # `class << self` only — `class << expr` for any other
-        # `expr` is treated as opaque so we don't accidentally
-        # record per-instance singleton methods under the
-        # surrounding class.
+        # `class << self` only — `class << expr` for any other `expr` is treated as opaque so we don't
+        # accidentally record per-instance singleton methods under the surrounding class.
         def descend_singleton_class(node, qualified_prefix, accumulator, budget)
           if node.expression.is_a?(Prism::SelfNode) && node.body
             walk_node(node.body, qualified_prefix, true, accumulator, budget)

data/lib/rigor/analysis/dependency_source_inference.rb

@@ -13,16 +13,12 @@ module Rigor
     #
     # The namespace coordinates three components:
     #
-    # - {GemResolver} maps a
-    #   `Configuration::Dependencies::Entry` to either a frozen
-    #   `Resolved(gem_name, version, gem_dir, mode, roots)` or an
-    #   `Unresolvable(gem_name, reason)` value.
-    # - {Builder.build} folds a `Configuration::Dependencies`
-    #   into a frozen {Index} carrying the partitioned outcomes.
-    # - {Index} holds the per-run state the dispatcher tier
-    #   consults via `#contribution_for`; the method table is
-    #   fully populated by {Walker} walking each resolved gem's
-    #   `roots:`.
+    # - {GemResolver} maps a `Configuration::Dependencies::Entry` to either a frozen
+    #   `Resolved(gem_name, version, gem_dir, mode, roots)` or an `Unresolvable(gem_name, reason)` value.
+    # - {Builder.build} folds a `Configuration::Dependencies` into a frozen {Index} carrying the partitioned
+    #   outcomes.
+    # - {Index} holds the per-run state the dispatcher tier consults via `#contribution_for`; the method table
+    #   is fully populated by {Walker} walking each resolved gem's `roots:`.
     module DependencySourceInference
     end
   end

data/lib/rigor/analysis/diagnostic.rb

@@ -3,47 +3,34 @@
 module Rigor
   module Analysis
     class Diagnostic
-      # The default source family. Matches the existing analyzer-
-      # internal rule families; serialised as `"builtin"` and is the
-      # baseline against which non-default families are recognised.
+      # The default source family. Matches the existing analyzer-internal rule families; serialised as
+      # `"builtin"` and is the baseline against which non-default families are recognised.
       DEFAULT_SOURCE_FAMILY = :builtin
 
       attr_reader :path, :line, :column, :message, :severity, :rule, :source_family,
                   :receiver_type, :method_name, :project_definition_site
 
-      # `rule:` is the stable identifier (a kebab-case string)
-      # of the diagnostic's source rule. It is used by the
-      # configuration and the in-source `# rigor:disable <rule>`
-      # suppression comment system to identify diagnostics by
-      # category. Diagnostics not produced by `CheckRules`
-      # (parse errors, path errors, internal analyzer errors)
-      # may leave `rule` as nil and stay unsuppressible.
+      # `rule:` is the stable identifier (a kebab-case string) of the diagnostic's source rule. It is used by
+      # the configuration and the in-source `# rigor:disable <rule>` suppression comment system to identify
+      # diagnostics by category. Diagnostics not produced by `CheckRules` (parse errors, path errors, internal
+      # analyzer errors) may leave `rule` as nil and stay unsuppressible.
       #
-      # `source_family:` names the producer of the rule. The default
-      # `:builtin` covers analyzer-internal rules; future families
-      # like `:rbs_extended`, `:generated`, or `"plugin.<id>"` (per
-      # ADR-2 § "Plugin Diagnostic Provenance") let consumers
-      # distinguish where a diagnostic originated without committing
-      # to the plugin API itself.
+      # `source_family:` names the producer of the rule. The default `:builtin` covers analyzer-internal
+      # rules; future families like `:rbs_extended`, `:generated`, or `"plugin.<id>"` (per ADR-2 § "Plugin
+      # Diagnostic Provenance") let consumers distinguish where a diagnostic originated without committing to
+      # the plugin API itself.
       #
-      # `receiver_type:` / `method_name:` are optional structured
-      # fields populated by the call-related rules (`call.undefined-
-      # method`) — the rendered receiver type and the called method
-      # name as plain strings. ADR-23 WD3 / slice 4: `rigor triage`'s
-      # heuristic recognisers read these directly instead of parsing
-      # the diagnostic message, so the catalogue no longer couples to
-      # message wording. Both stay nil for rules that have no such
-      # pair; a consumer that finds them nil falls back to message
-      # parsing.
+      # `receiver_type:` / `method_name:` are optional structured fields populated by the call-related rules
+      # (`call.undefined-method`) — the rendered receiver type and the called method name as plain strings.
+      # ADR-23 WD3 / slice 4: `rigor triage`'s heuristic recognisers read these directly instead of parsing
+      # the diagnostic message, so the catalogue no longer couples to message wording. Both stay nil for
+      # rules that have no such pair; a consumer that finds them nil falls back to message parsing.
       #
-      # `project_definition_site:` is an optional `"path:line"` string
-      # set by `call.undefined-method` when the project itself defines
-      # the called method on the receiver class somewhere in the
-      # analyzed file set (a reopened core/stdlib/gem class the
-      # dispatcher does not apply cross-file — see ADR-17). Its presence
-      # is the high-confidence "this is a project monkey-patch, not a
-      # bug" signal `rigor triage` keys on to recommend `pre_eval:`.
-      # Nil for every other diagnostic.
+      # `project_definition_site:` is an optional `"path:line"` string set by `call.undefined-method` when
+      # the project itself defines the called method on the receiver class somewhere in the analyzed file set
+      # (a reopened core/stdlib/gem class the dispatcher does not apply cross-file — see ADR-17). Its
+      # presence is the high-confidence "this is a project monkey-patch, not a bug" signal `rigor triage` keys
+      # on to recommend `pre_eval:`. Nil for every other diagnostic.
       def initialize(path:, line:, column:, message:, severity: :error, rule: nil, # rubocop:disable Metrics/ParameterLists
                      source_family: DEFAULT_SOURCE_FAMILY,
                      receiver_type: nil, method_name: nil, project_definition_site: nil)
@@ -62,16 +49,13 @@ module Rigor
         @project_definition_site = project_definition_site
       end
 
-      # Builds a Diagnostic positioned at a Prism node. Internalises
-      # the load-bearing convention every caller otherwise repeats:
-      # the line is the node's 1-based `start_line` and the column is
-      # `start_column + 1` (Prism columns are 0-based; Rigor reports
-      # 1-based). Pass any node responding to `#location`; all other
-      # fields forward to `#initialize` unchanged.
+      # Builds a Diagnostic positioned at a Prism node. Internalises the load-bearing convention every caller
+      # otherwise repeats: the line is the node's 1-based `start_line` and the column is `start_column + 1`
+      # (Prism columns are 0-based; Rigor reports 1-based). Pass any node responding to `#location`; all
+      # other fields forward to `#initialize` unchanged.
       #
-      # `Plugin::Base#diagnostic` wraps this for plugin authors (who
-      # must not set `source_family` — the runner stamps it); core
-      # rules and other producers call it directly.
+      # `Plugin::Base#diagnostic` wraps this for plugin authors (who must not set `source_family` — the
+      # runner stamps it); core rules and other producers call it directly.
       def self.from_node(node, path:, message:, severity: :error, rule: nil, # rubocop:disable Metrics/ParameterLists
                          source_family: DEFAULT_SOURCE_FAMILY,
                          receiver_type: nil, method_name: nil, project_definition_site: nil)
@@ -82,12 +66,10 @@ module Rigor
         )
       end
 
-      # Builds a Diagnostic from an explicit Prism location, applying
-      # the same 1-based `line` / `start_column + 1` convention as
-      # {.from_node}. Use this when the diagnostic should point at a
-      # *sub-location* rather than the whole node — most often a call's
-      # `message_loc` (the matcher / method name) instead of the
-      # receiver-spanning `node.location`. {.from_node} is sugar for
+      # Builds a Diagnostic from an explicit Prism location, applying the same 1-based `line` /
+      # `start_column + 1` convention as {.from_node}. Use this when the diagnostic should point at a
+      # *sub-location* rather than the whole node — most often a call's `message_loc` (the matcher / method
+      # name) instead of the receiver-spanning `node.location`. {.from_node} is sugar for
       # `from_location(node.location, …)`.
       def self.from_location(location, path:, message:, severity: :error, rule: nil, # rubocop:disable Metrics/ParameterLists
                              source_family: DEFAULT_SOURCE_FAMILY,
@@ -102,20 +84,17 @@ module Rigor
         )
       end
 
-      # Builds a Diagnostic at a call node's `message_loc` (the
-      # method-name / matcher span), falling back to the receiver-
-      # spanning `node.location` when no message location is available.
-      # Absorbs the `node.message_loc || node.location` idiom the
-      # call-related rules otherwise repeat; all other fields forward to
-      # {.from_location}.
+      # Builds a Diagnostic at a call node's `message_loc` (the method-name / matcher span), falling back to
+      # the receiver-spanning `node.location` when no message location is available. Absorbs the
+      # `node.message_loc || node.location` idiom the call-related rules otherwise repeat; all other fields
+      # forward to {.from_location}.
       def self.from_message_loc(node, **)
         from_location(node.message_loc || node.location, **)
       end
 
-      # Builds a Diagnostic at a definition / assignment node's
-      # `name_loc` (the declared name span), falling back to
-      # `node.location`. Absorbs the `node.name_loc || node.location`
-      # idiom the def / write rules otherwise repeat.
+      # Builds a Diagnostic at a definition / assignment node's `name_loc` (the declared name span), falling
+      # back to `node.location`. Absorbs the `node.name_loc || node.location` idiom the def / write rules
+      # otherwise repeat.
       def self.from_name_loc(node, **)
         from_location(node.name_loc || node.location, **)
       end
@@ -124,10 +103,9 @@ module Rigor
         severity == :error
       end
 
-      # The fully-qualified rule identifier — `<source_family>.<rule>`
-      # when the source is non-default, or just `<rule>` for the
-      # `:builtin` family. Returns nil when `rule` itself is nil
-      # (e.g. parse errors and internal-analyzer errors).
+      # The fully-qualified rule identifier — `<source_family>.<rule>` when the source is non-default, or
+      # just `<rule>` for the `:builtin` family. Returns nil when `rule` itself is nil (e.g. parse errors and
+      # internal-analyzer errors).
       def qualified_rule
         return nil if rule.nil?
         return rule if source_family == DEFAULT_SOURCE_FAMILY
@@ -135,12 +113,10 @@ module Rigor
         "#{source_family}.#{rule}"
       end
 
-      # `--format json` serialisation. The structured `receiver_type`
-      # / `method_name` / `project_definition_site` fields are emitted
-      # only when populated, so a consumer (`jq`, `rigor triage`, an AI
-      # agent) can group a `rigor check --format json` stream by the
-      # called class / method without parsing the human-readable
-      # `message` — the message wording is presentation, not contract.
+      # `--format json` serialisation. The structured `receiver_type` / `method_name` /
+      # `project_definition_site` fields are emitted only when populated, so a consumer (`jq`, `rigor
+      # triage`, an AI agent) can group a `rigor check --format json` stream by the called class / method
+      # without parsing the human-readable `message` — the message wording is presentation, not contract.
       def to_h
         base = {
           "path" => path,
@@ -157,13 +133,10 @@ module Rigor
         base
       end
 
-      # Text rendering for `rigor check`. The qualified rule
-      # identifier (per ADR-2 § "Plugin Diagnostic Provenance" —
-      # `plugin.<id>.<rule>`, `rbs_extended.<rule>`,
-      # `generated.<provider>.<rule>`) is appended in brackets
-      # whenever the diagnostic carries a non-default `source_family`,
-      # so plugin / RBS::Extended / generated provenance is visible
-      # in the standard text output without changing the layout for
+      # Text rendering for `rigor check`. The qualified rule identifier (per ADR-2 § "Plugin Diagnostic
+      # Provenance" — `plugin.<id>.<rule>`, `rbs_extended.<rule>`, `generated.<provider>.<rule>`) is appended
+      # in brackets whenever the diagnostic carries a non-default `source_family`, so plugin / RBS::Extended
+      # / generated provenance is visible in the standard text output without changing the layout for
       # built-in rules. Slice 5 (v0.1.0) wires this surface.
       def to_s
         base = "#{path}:#{line}:#{column}: #{severity}: #{message}"

data/lib/rigor/analysis/erb_template_detector.rb

@@ -2,31 +2,26 @@
 
 module Rigor
   module Analysis
-    # Detects when a `.rb` file is actually an ERB template — a Rails
-    # generator `templates/foo.rb` shape that uses `<%= ... %>` to
-    # interpolate identifiers. Prism rejects the template as invalid
-    # Ruby and the analyzer emits one parse-error diagnostic per scrap
-    # the parser tripped over (≈ 20 on Redmine's
-    # `lib/generators/redmine_plugin_model/templates/migration.rb`),
-    # all of them noise from the user's perspective. The runner / worker
-    # consults this detector before turning parse errors into
-    # diagnostics; an ERB-shaped source is silently skipped.
+    # Detects when a `.rb` file is actually an ERB template — a Rails generator `templates/foo.rb` shape that
+    # uses `<%= ... %>` to interpolate identifiers. Prism rejects the template as invalid Ruby and the analyzer
+    # emits one parse-error diagnostic per scrap the parser tripped over (≈ 20 on Redmine's
+    # `lib/generators/redmine_plugin_model/templates/migration.rb`), all of them noise from the user's
+    # perspective. The runner / worker consults this detector before turning parse errors into diagnostics; an
+    # ERB-shaped source is silently skipped.
     #
-    # Detection is byte-level on the raw source: any occurrence of the
-    # `%>` closing marker proves the file is an ERB template. `%>`
-    # cannot appear in valid Ruby — `%` is a binary operator that
-    # requires an operand on its right side, never `>`. The opening
-    # `<%` is ambiguous in principle (`x<%y` parses as `x < %y`, a
-    # comparison against a `%`-literal) but a real Ruby file with that
-    # shape would still not contain the closing `%>`.
+    # Detection is byte-level on the raw source: any occurrence of the `%>` closing marker proves the file is
+    # an ERB template. `%>` cannot appear in valid Ruby — `%` is a binary operator that requires an operand on
+    # its right side, never `>`. The opening `<%` is ambiguous in principle (`x<%y` parses as `x < %y`, a
+    # comparison against a `%`-literal) but a real Ruby file with that shape would still not contain the
+    # closing `%>`.
     module ErbTemplateDetector
       ERB_CLOSING_MARKER = /%>/
 
       module_function
 
       # @param parse_result [Prism::ParseResult]
-      # @return [Boolean] true when the parsed source looks like an
-      #   ERB template (parse errors expected; analysis should skip).
+      # @return [Boolean] true when the parsed source looks like an ERB template (parse errors expected;
+      #   analysis should skip).
       def template?(parse_result)
         source = parse_result.source.source
         return false unless source.is_a?(String) && !source.empty?

data/lib/rigor/analysis/fact_store.rb

@@ -4,11 +4,9 @@ module Rigor
   module Analysis
     # Immutable storage for flow-sensitive facts attached to a Scope snapshot.
     #
-    # Six buckets (see BUCKETS): local_binding, captured_local,
-    # object_content, global_storage, dynamic_origin, relational.
-    # Callers can record facts, invalidate all facts that mention a target,
-    # and conservatively join two stores by retaining only facts that both
-    # incoming edges share.
+    # Six buckets (see BUCKETS): local_binding, captured_local, object_content, global_storage, dynamic_origin,
+    # relational. Callers can record facts, invalidate all facts that mention a target, and conservatively
+    # join two stores by retaining only facts that both incoming edges share.
     class FactStore
       BUCKETS = %i[
         local_binding
@@ -48,13 +46,9 @@ module Rigor
       attr_reader :facts
 
       class << self
-        # ADR-15 Phase 4b.x — return the eagerly-loaded
-        # singleton-class `@empty` ivar. Lazy `@empty ||= new`
-        # would write to a class/module ivar from non-main
-        # Ractors and trip `Ractor::IsolationError`. The
-        # `@empty = new.freeze` at module body below
-        # pre-populates the ivar on the main Ractor at load
-        # time.
+        # ADR-15 Phase 4b.x — return the eagerly-loaded singleton-class `@empty` ivar. Lazy `@empty ||= new`
+        # would write to a class/module ivar from non-main Ractors and trip `Ractor::IsolationError`. The
+        # `@empty = new.freeze` at module body below pre-populates the ivar on the main Ractor at load time.
         attr_reader :empty
       end
 
@@ -131,11 +125,9 @@ module Rigor
         unique.freeze
       end
 
-      # `fact.target` is `Target | Array[Target]` per the carrier
-      # contract. Branching with an early return on the `Array`
-      # arm lets type narrowing collapse the post-return value to
-      # the bare `Target` case, so the wrapped tuple is `[Target]`
-      # and the union of return paths is exactly `Array[Target]`.
+      # `fact.target` is `Target | Array[Target]` per the carrier contract. Branching with an early return on
+      # the `Array` arm lets type narrowing collapse the post-return value to the bare `Target` case, so the
+      # wrapped tuple is `[Target]` and the union of return paths is exactly `Array[Target]`.
       def fact_targets(fact)
         target = fact.target
         return target if target.is_a?(Array)
@@ -143,11 +135,9 @@ module Rigor
         [target]
       end
 
-      # ADR-15 Phase 4b.x — eager-load the singleton `@empty`
-      # on the main Ractor at module-load time. Workers then
-      # READ the populated ivar without ever attempting a
-      # class/module ivar WRITE (which non-main Ractors are
-      # forbidden from doing).
+      # ADR-15 Phase 4b.x — eager-load the singleton `@empty` on the main Ractor at module-load time. Workers
+      # then READ the populated ivar without ever attempting a class/module ivar WRITE (which non-main
+      # Ractors are forbidden from doing).
       @empty = new.freeze
     end
   end