rigortype 0.2.4 → 0.2.6

data/lib/rigor/inference/expression_typer.rb

@@ -9,6 +9,7 @@ require_relative "../analysis/self_call_resolution_recorder"
 require_relative "block_parameter_binder"
 require_relative "body_fixpoint"
 require_relative "budget_trace"
+require_relative "dynamic_origin"
 require_relative "fallback"
 require_relative "flow_tracer"
 require_relative "indexed_narrowing"
@@ -224,15 +225,20 @@ module Rigor
       def initialize(scope:, tracer: nil)
         @scope = scope
         @tracer = tracer
+        @typing_node = nil
       end
 
       def type_of(node)
-        return untraced_type_of(node) unless FlowTracer.active?
-
-        # `rigor trace` — bracket the recursion with enter/result events.
-        # The tracer is observational only: the inferred type flows
-        # through unchanged (see FlowTracer's contract).
-        FlowTracer.trace_node(node) { untraced_type_of(node) }
+        previous = @typing_node
+        @typing_node = node
+        result = if FlowTracer.active?
+                   FlowTracer.trace_node(node) { untraced_type_of(node) }
+                 else
+                   untraced_type_of(node)
+                 end
+        result
+      ensure
+        @typing_node = previous
       end
 
       def untraced_type_of(node)
@@ -1011,11 +1017,12 @@ module Rigor
 
       def fallback_for(node, family:)
         inner = dynamic_top
-        record_fallback(node, family: family, inner_type: inner)
+        record_fallback(node, family: family, inner_type: inner, origin: DynamicOrigin::UNSUPPORTED_SYNTAX)
+        scope.record_dynamic_origin(node, DynamicOrigin::UNSUPPORTED_SYNTAX)
         inner
       end
 
-      def record_fallback(node, family:, inner_type:)
+      def record_fallback(node, family:, inner_type:, origin: nil)
         return unless tracer
 
         location = node.respond_to?(:location) ? node.location : nil
@@ -1023,7 +1030,8 @@ module Rigor
           node_class: node.class,
           location: location,
           family: family,
-          inner_type: inner_type
+          inner_type: inner_type,
+          origin: origin
         )
         tracer.record_fallback(event)
       end
@@ -2128,6 +2136,7 @@ module Rigor
       # this signature's summary sees the floor, not the stale `bot` seed.
       def degrade_entangled_fixpoint(summaries, plain_signature)
         BudgetTrace.hit(BudgetTrace::RECURSION_GUARD)
+        scope.record_dynamic_origin(@typing_node, DynamicOrigin::ANALYZER_BUDGET_CUTOFF) if @typing_node
         summaries[plain_signature][:assumption] = Type::Combinator.untyped
         Type::Combinator.untyped
       end
@@ -2152,6 +2161,7 @@ module Rigor
           # Out of iterations and still unstable — collapse to today's
           # widening behaviour.
           BudgetTrace.hit(BudgetTrace::RECURSION_FIXPOINT_CAP)
+          scope.record_dynamic_origin(@typing_node, DynamicOrigin::ANALYZER_BUDGET_CUTOFF) if @typing_node
           summaries[plain_signature][:assumption] = Type::Combinator.untyped
           return Type::Combinator.untyped
         end
@@ -2244,6 +2254,7 @@ module Rigor
         return type unless would_have_been_guarded && !fully_value_pinned?(type)
 
         BudgetTrace.hit(BudgetTrace::RECURSION_GUARD)
+        scope.record_dynamic_origin(@typing_node, DynamicOrigin::ANALYZER_BUDGET_CUTOFF) if @typing_node
         # ADR-55 WD1 clamp: a guarded extended frame whose body is non-pinned
         # must be byte-identical to the plain guard's `untyped`. This path
         # deliberately does NOT route to the in-progress fixpoint summary:
@@ -2363,7 +2374,8 @@ module Rigor
           locals: locals.freeze,
           self_type: receiver,
           discovery: scope.discovery,
-          struct_fold_safe_locals: struct_fold_safe_locals_for(def_node.body)
+          struct_fold_safe_locals: struct_fold_safe_locals_for(def_node.body),
+          dynamic_origins: scope.dynamic_origins
         )
       end
 

data/lib/rigor/inference/fallback.rb

@@ -20,8 +20,8 @@ module Rigor
     # - inner_type: the Rigor::Type returned to the caller (currently
     #   always Dynamic[Top]; later slices may carry richer fallback
     #   types).
-    class Fallback < Data.define(:node_class, :location, :family, :inner_type)
-      def initialize(node_class:, location:, family:, inner_type:)
+    class Fallback < Data.define(:node_class, :location, :family, :inner_type, :origin)
+      def initialize(node_class:, location:, family:, inner_type:, origin: nil)
         raise ArgumentError, "node_class must be a Class, got #{node_class.class}" unless node_class.is_a?(Class)
 
         unless FALLBACK_FAMILIES.include?(family)

data/lib/rigor/inference/method_dispatcher/constant_folding.rb

@@ -218,11 +218,27 @@ module Rigor
         # is what ultimately limits how wide an inferred type gets.
         UNION_FOLD_OUTPUT_LIMIT = 8
 
+        # ADR-78 — reflexive over-fold guard.
+        # Reflective dispatch (`public_send` / `send` / `__send__`) must
+        # NOT constant-fold unless the method-name argument is itself a
+        # value-pinned literal `Constant[Symbol]`. With a runtime-variable
+        # method name the dispatched method is not statically determined,
+        # so the call degrades to the RBS result (`untyped`) — exactly as
+        # it does without the guard, but explicit so a later shape-carrier
+        # preservation tier (ADR-76 WD2) cannot surface an over-fold as a
+        # spurious `flow.always-truthy-condition`.
+        REFLECTIVE_SEND_METHODS = %i[public_send send __send__].to_set.freeze
+
         # @return [Rigor::Type::Constant, Rigor::Type::Union, Rigor::Type::IntegerRange, nil]
         def try_dispatch(context)
           receiver = context.receiver
           method_name = context.method_name
           args = context.args
+
+          if REFLECTIVE_SEND_METHODS.include?(method_name)
+            first_arg = args.first
+            return nil unless first_arg.is_a?(Type::Constant) && first_arg.value.is_a?(Symbol)
+          end
           # v0.0.7 — `String#%` against a `Tuple` / `HashShape`
           # argument runs Ruby's format-string engine when both
           # sides are statically constant. The standard

data/lib/rigor/inference/method_dispatcher/shape_dispatch.rb

@@ -102,7 +102,11 @@ module Rigor
           find_index: :tuple_find_index,
           rindex: :tuple_rindex,
           flatten: :tuple_flatten,
-          join: :tuple_join
+          join: :tuple_join,
+          freeze: :shape_self,
+          dup: :shape_self,
+          clone: :shape_self,
+          itself: :shape_self
         }.freeze
 
         # Byte cap on a folded `tuple.join` result — a huge tuple times a
@@ -151,7 +155,23 @@ module Rigor
           :< => :hash_compare,
           :<= => :hash_compare,
           :> => :hash_compare,
-          :>= => :hash_compare
+          :>= => :hash_compare,
+          # ADR-76 WD2 / ADR-78 WD3 — pure self-returners preserve the
+          # `HashShape` carrier instead of degrading to the nominal `Hash`
+          # via the RBS `() -> self` signature, so
+          # `MESSAGES = {…}.freeze; MESSAGES[reason]` folds the value union
+          # rather than reading `Dynamic`. `dup` / `clone` produce a fresh
+          # object, but Rigor's shape carriers are immutable values, so
+          # preserving the carrier is sound for reads; a later in-place
+          # mutation routes through `MutationWidening`. (The `Tuple` table
+          # carries the same four entries; both became safe once the
+          # block-form over-fold guard landed in `try_dispatch` — ADR-78
+          # WD1 — so `CONST = [...].freeze; CONST.any? { … }` no longer
+          # folds the no-block result and fires a reflexive always-truthy.)
+          freeze: :shape_self,
+          dup: :shape_self,
+          clone: :shape_self,
+          itself: :shape_self
         }.freeze
 
         # @return [Rigor::Type, nil] the precise element/value type, or
@@ -189,6 +209,17 @@ module Rigor
           method_name = context.method_name
           args = context.args
           args ||= []
+          # ADR-78 WD1 — every shape handler folds *no-block* semantics; none
+          # evaluates a passed block. So a block-form call (`tuple.any? { … }`,
+          # `tuple.sum { … }`, `tuple.count { … }`) must NOT fold the no-block
+          # result — doing so ignores the block (an over-fold: `any? { false }`
+          # would still fold `Constant[true]`). Declining defers to BlockFolding
+          # / RBS. This is the over-fold class the Tuple shape-carrier
+          # preservation (ADR-76 WD2) surfaced as reflexive `always-truthy` on
+          # `CONST = [...].freeze; CONST.any? { … }`; fixing it at the fold (not
+          # the rule) unblocks that preservation.
+          return nil unless context.block_type.nil?
+
           handler = RECEIVER_HANDLERS[receiver.class]
           return nil unless handler
 
@@ -236,6 +267,14 @@ module Rigor
             send(handler, shape, method_name, args)
           end
 
+          # ADR-76 WD2 / ADR-78 WD3 — a pure self-returner
+          # (`freeze` / `dup` / `clone` / `itself`) returns the receiver
+          # carrier unchanged, preserving the shape that the nominal
+          # `() -> self` RBS signature would otherwise drop.
+          def shape_self(carrier, _method_name, _args)
+            carrier
+          end
+
           def dispatch_nominal_size(nominal, method_name, args)
             projection = nominal_projection(nominal, method_name, args)
             return projection if projection

data/lib/rigor/inference/method_dispatcher.rb

@@ -6,6 +6,7 @@ require_relative "../flow_contribution"
 require_relative "../flow_contribution/merger"
 require_relative "../builtins/hkt_builtins"
 require_relative "../builtins/static_return_refinements"
+require_relative "dynamic_origin"
 require_relative "flow_tracer"
 require_relative "method_dispatcher/call_context"
 require_relative "method_dispatcher/constant_folding"
@@ -83,7 +84,7 @@ module Rigor
         result
       end
 
-      def resolve(receiver_type:, method_name:, arg_types:, # rubocop:disable Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+      def resolve(receiver_type:, method_name:, arg_types:, # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
                   block_type: nil, environment: nil,
                   call_node: nil, scope: nil)
         return nil if receiver_type.nil?
@@ -114,7 +115,12 @@ module Rigor
         # are supplied — the dispatcher's own internal callers
         # (per-element block fold, etc.) skip this tier.
         plugin_result = try_plugin_contribution(call_node, scope, receiver_type)
-        return plugin_result if plugin_result
+        if plugin_result
+          if plugin_result.is_a?(Type::Dynamic)
+            scope&.record_dynamic_origin(call_node, DynamicOrigin::FRAMEWORK_DSL_BOUNDARY)
+          end
+          return plugin_result
+        end
 
         # ADR-20 slice 3 — Rigor-bundled HKT-builtin return-
         # type tier. Sits ABOVE `RbsDispatch.try_dispatch` so
@@ -145,6 +151,9 @@ module Rigor
         rbs_result = RbsDispatch.try_dispatch(context)
         if rbs_result
           record_boundary_cross_if_applicable(receiver_type, method_name, rbs_result, environment)
+          if rbs_result.is_a?(Type::Dynamic) && rbs_result.static_facet.is_a?(Type::Top)
+            scope&.record_dynamic_origin(call_node, DynamicOrigin::EXPLICIT_UNTYPED)
+          end
           return rbs_result
         end
 
@@ -174,7 +183,10 @@ module Rigor
         # `Dynamic[top]` so the patched call resolves
         # cross-file without `call.undefined-method`.
         patched_result = try_project_patched_method(receiver_type, method_name, environment)
-        return patched_result if patched_result
+        if patched_result
+          scope&.record_dynamic_origin(call_node, DynamicOrigin::EXTERNAL_GEM_WITHOUT_RBS)
+          return patched_result
+        end
 
         # ADR-10 slice 2b-ii — dependency-source inference tier.
         # Sits BELOW RBS dispatch (RBS / RBS::Inline / generated
@@ -186,7 +198,10 @@ module Rigor
         # dynamic-origin envelope; per-method return-type
         # precision is queued for a later slice.
         dep_source_result = try_dependency_source(receiver_type, method_name, environment)
-        return dep_source_result if dep_source_result
+        if dep_source_result
+          scope&.record_dynamic_origin(call_node, DynamicOrigin::EXTERNAL_GEM_WITHOUT_RBS)
+          return dep_source_result
+        end
 
         # v0.1.3 — discovered-method dispatch tier. When the
         # receiver class has no RBS BUT scope_indexer recorded

data/lib/rigor/inference/mutation_widening.rb

@@ -102,8 +102,22 @@ module Rigor
         replace
       ].to_set.freeze
 
+      # Methods that return the receiver (or a shallow copy) and
+      # cannot mutate it. They must not trigger widening or any
+      # other receiver-fact invalidation. The list is intentionally
+      # narrow — only methods whose purity is unconditional and
+      # whose return value is the receiver itself (or a copy that
+      # leaves the original untouched).
+      PURE_SELF_RETURNERS = %i[freeze dup clone itself].freeze
+
       module_function
 
+      # True when `method_name` is a pure self-returner that must
+      # not invalidate the receiver's facts.
+      def pure_self_returner?(method_name)
+        PURE_SELF_RETURNERS.include?(method_name)
+      end
+
       # Returns a scope with the call's receiver widened, when the
       # receiver is a local-/instance-variable read whose current
       # binding is a literal-shape carrier (`Tuple` / `HashShape`)
@@ -114,6 +128,8 @@ module Rigor
       # @param current_scope [Rigor::Scope]
       # @return              [Rigor::Scope]
       def widen_after_call(call_node:, current_scope:)
+        return current_scope if pure_self_returner?(call_node.name)
+
         receiver = call_node.receiver
         return current_scope if receiver.nil?
 
@@ -181,6 +197,8 @@ module Rigor
       end
 
       def widen_for_outer_receiver(call_node, scope)
+        return scope if pure_self_returner?(call_node.name)
+
         receiver = call_node.receiver
         return scope if receiver.nil?
 

data/lib/rigor/inference/protection_scanner.rb

@@ -19,7 +19,7 @@ module Rigor
     # (does a diagnostic fire) is the phased mutation tier.
     class ProtectionScanner
       # A single unprotected call site.
-      Site = Data.define(:line, :receiver, :method_name)
+      Site = Data.define(:line, :receiver, :method_name, :dynamic_origin)
 
       FileResult = Data.define(:protected_count, :unprotected_count, :sites) do
         def total = protected_count + unprotected_count
@@ -43,14 +43,17 @@ module Rigor
         Source::NodeWalker.each(root) do |node|
           next unless dispatch_site?(node)
 
-          receiver_type = index[node.receiver].type_of(node.receiver)
+          scope = index[node.receiver]
+          receiver_type = scope.type_of(node.receiver)
           if concrete_receiver?(receiver_type)
             protected_count += 1
           else
+            origin = scope.dynamic_origins[node.receiver]
             sites << Site.new(
               line: node.location.start_line,
               receiver: safe_describe(receiver_type),
-              method_name: node.name.to_s
+              method_name: node.name.to_s,
+              dynamic_origin: origin
             )
           end
         end

data/lib/rigor/inference/statement_evaluator.rb

@@ -1861,13 +1861,13 @@ module Rigor
       end
 
       # ADR-37 slice 2 / ADR-52 WD3 — gathers each plugin's post-return
-      # narrowing from the method-gated `type_specifier` DSL, wrapped as
+      # narrowing from the method-gated `narrowing_facts` DSL, wrapped as
       # a facts-only `FlowContribution`, swallowing per-plugin
       # exceptions so a buggy plugin can't abort the assertion path.
       EMPTY_CONTRIBUTIONS = [].freeze
       private_constant :EMPTY_CONTRIBUTIONS
 
-      # Fast-exit guard: skip if no plugin declares a `type_specifier`, or if
+      # Fast-exit guard: skip if no plugin declares a `narrowing_facts` rule, or if
       # no registered method-name gate matches the call. See
       # `collect_gated_statement_contributions` for the full consultation.
       def collect_plugin_contributions(registry, call_node, current_scope)
@@ -1882,7 +1882,7 @@ module Rigor
       end
 
       # ADR-37 slice 2 / ADR-52 WD1 — post-gate walk in registry order.
-      # Visits only plugins in `for_statement` (declare a `type_specifier`),
+      # Visits only plugins in `for_statement` (declare a `narrowing_facts` rule),
       # further gated by the method-name Set probe so the common no-candidate
       # case is a single lookup. Accumulates lazily; caller is read-only.
       def collect_gated_statement_contributions(index, relevant, name, call_node, current_scope)
@@ -2918,7 +2918,8 @@ module Rigor
           environment: scope.environment,
           locals: {}.freeze,
           source_path: scope.source_path,
-          discovery: scope.discovery
+          discovery: scope.discovery,
+          dynamic_origins: scope.dynamic_origins
         )
       end
 

data/lib/rigor/plugin/base.rb

@@ -20,7 +20,7 @@ module Rigor
     #
     # This class implements all plugin protocol hooks: per-call
     # return-type contributions (`dynamic_return`), narrowing-fact
-    # contributions (`type_specifier`), AST node rules (`node_rule`),
+    # contributions (`narrowing_facts`), AST node rules (`node_rule`),
     # and producer/cache hooks. Cumulative implementation per the
     # ADR-37 / ADR-52 slice chain.
     #
@@ -440,19 +440,32 @@ module Rigor
         # `post_return_facts` slot of the deleted `flow_contribution_for`
         # hook (ADR-52 WD3):
         #
-        #   type_specifier methods: [:assert_kind_of] do |call_node, scope|
+        #   narrowing_facts methods: [:assert_kind_of] do |call_node, scope|
         #     # return an Array of post-return facts, or nil
         #   end
         #
         # `methods:` is a non-empty Array of method names; the engine
         # calls the block only when `call_node.name` is one of them. The
         # block returns the same `post_return_facts` the merger applies.
-        def type_specifier(methods:, &block)
-          raise ArgumentError, "Plugin::Base.type_specifier requires a block body" if block.nil?
+        #
+        # This hook supplies post-return *narrowing facts* — the
+        # predicate/assertion edges a call establishes about its
+        # arguments or receiver, e.g. `assert_kind_of(String, x)` ⇒ `x`
+        # is narrowed to `String` on the continuation. It does NOT give a
+        # call a *type*; for that use {dynamic_return} (per-call-site) or
+        # contribute RBS via the manifest `signature_paths:`.
+        # `dynamic_return` is the type slot, this is the fact slot.
+        #
+        # Renamed from `type_specifier` (ADR-80): the old name read as a
+        # parallel to `dynamic_return` (a type) when it actually returns
+        # facts. {.type_specifier} survives as a deprecating alias through
+        # 0.2.x and is removed in 0.3.0.
+        def narrowing_facts(methods:, &block)
+          raise ArgumentError, "Plugin::Base.narrowing_facts requires a block body" if block.nil?
           unless methods.is_a?(Array) && !methods.empty? &&
                  methods.all? { |m| m.is_a?(Symbol) || (m.is_a?(String) && !m.empty?) }
             raise ArgumentError,
-                  "Plugin::Base.type_specifier methods: must be a non-empty Array of Symbol/String, " \
+                  "Plugin::Base.narrowing_facts methods: must be a non-empty Array of Symbol/String, " \
                   "got #{methods.inspect}"
           end
 
@@ -461,6 +474,20 @@ module Rigor
           nil
         end
 
+        # DEPRECATED (ADR-80) — renamed to {.narrowing_facts}. This hook
+        # supplies post-return narrowing *facts*, not a type; the old
+        # name misleads by parallel with {.dynamic_return}. Retained as a
+        # warning-emitting alias through 0.2.x; REMOVED in 0.3.0. Migrate
+        # `type_specifier methods: …` → `narrowing_facts methods: …`.
+        def type_specifier(methods:, &)
+          unless @type_specifier_deprecation_warned
+            @type_specifier_deprecation_warned = true
+            warn("[rigor] Plugin::Base.type_specifier is deprecated (ADR-80) and will be " \
+                 "removed in Rigor 0.3.0; rename it to `narrowing_facts`. (#{name})")
+          end
+          narrowing_facts(methods:, &)
+        end
+
         # Frozen snapshot of the declared type-specifier rules. Memoised
         # for the same reason as {dynamic_returns} — consulted per plugin
         # per dispatch, over an array fixed at class-definition time.
@@ -504,7 +531,7 @@ module Rigor
       # production users migrated. Per-call return types are declared via
       # the gated {.dynamic_return} DSL (static / run-time / per-file
       # name sets, static / run-time receiver sets); post-return
-      # narrowing facts via {.type_specifier}. See the CHANGELOG
+      # narrowing facts via {.narrowing_facts}. See the CHANGELOG
       # migration note for the idiom-by-idiom mapping.
 
       # ADR-9 slice 3 — per-run preparation hook. The runner
@@ -625,7 +652,7 @@ module Rigor
       end
 
       # ADR-37 slice 2 — the post-return narrowing facts contributed by
-      # this plugin's {.type_specifier} rules for a call. The engine
+      # this plugin's {.narrowing_facts} rules for a call. The engine
       # calls this from `StatementEvaluator`; a rule fires only when
       # `call_node.name`
       # is one of its declared `methods:`. Failures isolate to [].

data/lib/rigor/plugin/registry.rb

@@ -148,7 +148,7 @@ module Rigor
               "plugin #{(plugin.class.name || plugin.class).inspect} defines `flow_contribution_for`, " \
               "which was removed (ADR-52). Declare the per-call return type via `dynamic_return` " \
               "(receivers:/methods:/file_methods: gates, static or callable) and post-return narrowing " \
-              "facts via `type_specifier` — see the CHANGELOG migration note."
+              "facts via `narrowing_facts` — see the CHANGELOG migration note."
       end
 
       # Same `Method#owner` trick for the per-file diagnostics hook —

data/lib/rigor/scope.rb

@@ -23,7 +23,8 @@ module Rigor
                 :ivars, :cvars, :globals,
                 :indexed_narrowings, :method_chain_narrowings,
                 :declaration_sourced,
-                :source_path, :discovery, :struct_fold_safe_locals
+                :source_path, :discovery, :struct_fold_safe_locals,
+                :dynamic_origins
 
     # ADR-53 Track A — the seed-time discovery tables live on the
     # {DiscoveryIndex} the scope carries by a single reference; the
@@ -122,6 +123,11 @@ module Rigor
       end
     end
 
+    def record_dynamic_origin(node, cause)
+      @dynamic_origins[node] = cause
+      self
+    end
+
     def initialize(
       environment:, locals:,
       fact_store: Analysis::FactStore.empty,
@@ -134,7 +140,8 @@ module Rigor
       method_chain_narrowings: EMPTY_CHAIN_NARROWINGS,
       declaration_sourced: EMPTY_DECLARATION_SOURCED,
       source_path: nil,
-      struct_fold_safe_locals: EMPTY_FOLD_SAFE
+      struct_fold_safe_locals: EMPTY_FOLD_SAFE,
+      dynamic_origins: {}.compare_by_identity
     )
       @environment = environment
       @locals = locals
@@ -149,6 +156,7 @@ module Rigor
       @declaration_sourced = declaration_sourced
       @source_path = source_path
       @struct_fold_safe_locals = struct_fold_safe_locals
+      @dynamic_origins = dynamic_origins
       freeze
     end
 
@@ -716,7 +724,8 @@ module Rigor
       method_chain_narrowings: @method_chain_narrowings,
       declaration_sourced: @declaration_sourced,
       source_path: @source_path,
-      struct_fold_safe_locals: @struct_fold_safe_locals
+      struct_fold_safe_locals: @struct_fold_safe_locals,
+      dynamic_origins: @dynamic_origins
     )
       self.class.new(
         environment: environment, locals: locals,
@@ -727,7 +736,8 @@ module Rigor
         method_chain_narrowings: method_chain_narrowings,
         declaration_sourced: declaration_sourced,
         source_path: source_path,
-        struct_fold_safe_locals: struct_fold_safe_locals
+        struct_fold_safe_locals: struct_fold_safe_locals,
+        dynamic_origins: dynamic_origins
       )
     end
 
@@ -764,7 +774,8 @@ module Rigor
         # flow-live (a method-local nil write / failed-guard narrowing), the
         # merge is flow-live and `possible-nil-receiver` fires as before.
         declaration_sourced: join_declaration_sourced(other),
-        source_path: source_path
+        source_path: source_path,
+        dynamic_origins: @dynamic_origins
       )
     end
 

data/lib/rigor/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Rigor
-  VERSION = "0.2.4"
+  VERSION = "0.2.6"
 end

data/lib/rigor.rb

@@ -10,6 +10,7 @@ require_relative "rigor/environment"
 require_relative "rigor/rbs_extended"
 require_relative "rigor/testing"
 require_relative "rigor/inference/budget_trace"
+require_relative "rigor/inference/dynamic_origin"
 require_relative "rigor/inference/fallback"
 require_relative "rigor/inference/fallback_tracer"
 require_relative "rigor/inference/acceptance"

data/plugins/rigor-minitest/lib/rigor/plugin/minitest/assertion_analyzer.rb

@@ -145,7 +145,7 @@ module Rigor
         private_constant :SPEC_MATCHER_FORM
 
         # ADR-37 slice 2 — the method names this analyzer narrows on,
-        # for the plugin's `type_specifier methods:` gate.
+        # for the plugin's `narrowing_facts methods:` gate.
         SUPPORTED_METHODS = (ASSERT_FORM.keys + SPEC_MATCHER_FORM.keys).freeze
 
         def spec_form_fact(call_node, environment:)

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

@@ -78,7 +78,7 @@ module Rigor
       # assertion, method-gated by the engine. The engine routes
       # `:local`-kind facts through
       # `StatementEvaluator#apply_local_post_return_fact`.
-      type_specifier methods: AssertionAnalyzer::SUPPORTED_METHODS do |call_node, scope|
+      narrowing_facts methods: AssertionAnalyzer::SUPPORTED_METHODS do |call_node, scope|
         AssertionAnalyzer.contribution_for(call_node, environment: scope&.environment)&.post_return_facts
       end
     end

data/plugins/rigor-rails-i18n/lib/rigor/plugin/rails_i18n/analyzer.rb

@@ -42,6 +42,32 @@ module Rigor
         # `_controller.rb` (e.g. `users`, `admin/users`).
         CONTROLLER_PATH_RE = %r{(?:^|/)controllers/(.+)_controller\.rb$}
 
+        # Matches Rails view-template file paths to derive the
+        # I18n "virtual path" — the scope that Rails uses for
+        # lazy `t('.key')` lookups inside a template.
+        #
+        # Captures the path segment between `views/` and the
+        # format+variant+handler suffix, then strips a leading
+        # underscore from each segment — Rails templates resolve
+        # `_form.html.erb` as "form", not "_form".
+        #
+        #   app/views/setting/index.html.erb      → setting.index
+        #   app/views/admin/users/new.html.erb    → admin.users.new
+        #   app/views/home/index.html+mobile.erb  → home.index
+        #   app/views/users/_form.html.erb        → users.form
+        #
+        # The view-scope lazy expansion replaces the action
+        # part with the view's virtual path:
+        #   `<%= t('.title') %>` → `setting.index.title`
+        VIEW_SCOPE_RE = %r{views/(.+?)\.(?:\w+)(?:\+\w+)?\.\w+\z}
+
+        # Regex to extract lazy-key arguments from ERB / HTML
+        # template content. Matches `t('.key')`, `t(".key")`,
+        # `I18n.t('.key')`, and `I18n.translate('.key')` with a
+        # leading dot on the key string. Captures only the key
+        # part after the dot.
+        LAZY_T_KEY_RE = /\b(?:I18n\.)?(?:t|translate)\s*\(\s*(?:"\.([^"\\]*)"|'\.([^'\\]*)')/
+
         # Reserved option keys — these are recognised by I18n
         # itself and not treated as interpolation variables.
         RESERVED_OPTION_KEYS = %i[
@@ -146,6 +172,32 @@ module Rigor
           m[1].tr("/", ".")
         end
 
+        def view_scope_from_path(path)
+          m = VIEW_SCOPE_RE.match(path.to_s)
+          return nil unless m
+
+          m[1].split("/").map { |seg| seg.sub(/\A_/, "") }.join(".")
+        end
+
+        def extract_lazy_keys_from_erb(content)
+          content.scan(LAZY_T_KEY_RE).map { |dq, sq| dq || sq }.uniq
+        end
+
+        def validate_view_key(key, locale_index:, configured_locales:)
+          entry = locale_index.find(key)
+          if entry.nil?
+            return [] if locale_index.pluralization_namespace?(key)
+            return [] if rails_shipped_key?(key)
+
+            return [unknown_key_violation(key, locale_index)]
+          end
+
+          violations = [translation_call_info(key, entry)]
+          missing = locale_index.missing_locales_for(key, configured_locales: configured_locales)
+          violations << missing_locale_violation(key, missing) unless missing.empty?
+          violations
+        end
+
         # Expands a lazy key (starting with `.`) to its full
         # dotted path using the controller scope and action name.
         # Returns the raw key unchanged for absolute keys.