rigortype 0.2.5 → 0.2.6

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.5"
+  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-rspec/lib/rigor/plugin/rspec.rb

@@ -110,7 +110,7 @@ module Rigor
       # ADR-37 slice 2 — matcher narrowing
       # (`expect(x).to be_a(T)` → `post_return_facts` on `x`),
       # method-gated by the engine on the expectation verbs.
-      type_specifier methods: %i[to not_to to_not] do |call_node, scope|
+      narrowing_facts methods: %i[to not_to to_not] do |call_node, scope|
         MatcherAnalyzer.contribution_for(call_node, environment: scope&.environment)&.post_return_facts
       end
 

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

@@ -169,13 +169,13 @@ module Rigor
       end
 
       # ADR-52 slice 4 — `T.bind(self, T)`'s self-narrowing fact,
-      # contributed via the method-gated `type_specifier` DSL. The
+      # contributed via the method-gated `narrowing_facts` DSL. The
       # statement evaluator consults this path for narrowing facts.
       # The return-type half (`Constant[nil]`) flows through the
       # `dynamic_return` rule above; the block re-checks the `T.`
       # receiver via the recogniser, so an unrelated `bind` call
       # contributes nothing.
-      type_specifier methods: [:bind] do |call_node, scope|
+      narrowing_facts methods: [:bind] do |call_node, scope|
         bind_post_return_facts(call_node, scope)
       end
 
@@ -258,7 +258,7 @@ module Rigor
         lookup_signature(call_node, scope)&.return_type
       end
 
-      # The `type_specifier` body for `T.bind` — same sigil gate as
+      # The `narrowing_facts` body for `T.bind` — same sigil gate as
       # the return-type path, then the recogniser's
       # `post_return_facts` (the `Fact(target_kind: :self)` that
       # narrows `scope.self_type` for the rest of the block).

data/sig/rigor/plugin/base.rbs

@@ -26,6 +26,8 @@ class Rigor::Plugin::Base
   def self.dynamic_return: (?receivers: (Array[String] | ^() -> Array[String])?, ?methods: (Array[untyped] | ^() -> Array[untyped])?) { (untyped call_node, untyped scope) -> untyped } -> nil
   def self.dynamic_returns: () -> Array[untyped]
 
+  def self.narrowing_facts: (methods: Array[untyped]) { (untyped call_node, untyped scope) -> untyped } -> nil
+  # Deprecating alias for `narrowing_facts` (ADR-80); removed in 0.3.0.
   def self.type_specifier: (methods: Array[untyped]) { (untyped call_node, untyped scope) -> untyped } -> nil
   def self.type_specifiers: () -> Array[untyped]
 

data/sig/rigor/scope.rbs

@@ -8,6 +8,7 @@ module Rigor
     attr_reader cvars: Hash[Symbol, Type::t]
     attr_reader globals: Hash[Symbol, Type::t]
     attr_reader discovery: DiscoveryIndex
+    attr_reader dynamic_origins: Hash[untyped, Symbol]
     attr_reader indexed_narrowings: Hash[IndexedKey, Type::t]
     attr_reader method_chain_narrowings: Hash[ChainKey, Type::t]
     attr_reader source_path: String?
@@ -32,6 +33,7 @@ module Rigor
     def data_member_layouts: () -> Hash[String, Array[Symbol]]
     def struct_member_layouts: () -> Hash[String, { members: Array[Symbol], keyword_init: bool }]
     def param_inferred_types: () -> Hash[[String, Symbol, Symbol], Hash[Symbol, Type::t]]
+    def record_dynamic_origin: (untyped node, Symbol cause) -> Scope
 
     class DiscoveryIndex
       attr_reader declared_types: Hash[untyped, Type::t]
@@ -71,7 +73,7 @@ module Rigor
 
     def self.empty: (?environment: Environment, ?source_path: String?) -> Scope
 
-    def initialize: (environment: Environment, locals: Hash[Symbol, Type::t], ?fact_store: Analysis::FactStore, ?self_type: Type::t?, ?ivars: Hash[Symbol, Type::t], ?cvars: Hash[Symbol, Type::t], ?globals: Hash[Symbol, Type::t], ?discovery: DiscoveryIndex, ?source_path: String?) -> void
+    def initialize: (environment: Environment, locals: Hash[Symbol, Type::t], ?fact_store: Analysis::FactStore, ?self_type: Type::t?, ?ivars: Hash[Symbol, Type::t], ?cvars: Hash[Symbol, Type::t], ?globals: Hash[Symbol, Type::t], ?discovery: DiscoveryIndex, ?source_path: String?, ?dynamic_origins: Hash[untyped, Symbol]) -> void
     def with_source_path: (String? path) -> Scope
     def with_struct_fold_safe: (Set[Symbol] locals) -> Scope
     def struct_fold_safe?: (String | Symbol name) -> bool

data/skills/rigor-plugin-author/SKILL.md

@@ -97,19 +97,22 @@ AST walk per file — hands every matching node to the block along with a
 `scope` it can query for inferred types. The block returns an array of
 `Rigor::Analysis::Diagnostic` (built via the `diagnostic` helper).
 Optionally the plugin also declares `dynamic_return(receivers:)` /
-`type_specifier(methods:)` to *supply* a return type or narrowing facts
-for call sites the core analyzer types as `Dynamic`. `#diagnostics_for_file`
+`narrowing_facts(methods:)` to *supply* a return type or narrowing facts
+for call sites the core analyzer types as `Dynamic`. (`narrowing_facts`
+was renamed from `type_specifier` in ADR-80; `type_specifier` remains as a
+deprecating alias removed in 0.3.0 — use `narrowing_facts` in new plugins.)
+`#diagnostics_for_file`
 is the file-rule surface for whole-file diagnostics a per-node walk can't
 express. (`flow_contribution_for` was removed pre-1.0 in ADR-52 WD3 —
 defining it now raises `ArgumentError`; use `dynamic_return` /
-`type_specifier`. See Phase 2.)
+`narrowing_facts`. See Phase 2.)
 
 ## Phase outline
 
 | Phase | What | Reference |
 | --- | --- | --- |
 | 1 | Package and scaffold — gem vs project-private layout, gemspec / Gemfile, the plugin class skeleton, `.rigor.yml` activation. | [`references/01-plan-and-scaffold.md`](references/01-plan-and-scaffold.md) |
-| 2 | Node rules — `node_rule` (engine-owned walk), building `Diagnostic`s via `Base#diagnostic`, querying `scope.type_of`, calling the target library directly instead of reimplementing it (ADR-39: `Plugin::Inflector`, `Base.suggest`), optional `dynamic_return` / `type_specifier`, RBS for the DSL. | [`references/02-walker-and-types.md`](references/02-walker-and-types.md) |
+| 2 | Node rules — `node_rule` (engine-owned walk), building `Diagnostic`s via `Base#diagnostic`, querying `scope.type_of`, calling the target library directly instead of reimplementing it (ADR-39: `Plugin::Inflector`, `Base.suggest`), optional `dynamic_return` / `narrowing_facts`, RBS for the DSL. | [`references/02-walker-and-types.md`](references/02-walker-and-types.md) |
 | 3 | Test and ship — fixture-based tests (RSpec / Minitest, no rigor internals), version pinning, README, publish or keep private. | [`references/03-test-and-ship.md`](references/03-test-and-ship.md) |
 
 ## Reading order — modules
@@ -117,5 +120,5 @@ defining it now raises `ArgumentError`; use `dynamic_return` /
 | Module | Read | Covers |
 | --- | --- | --- |
 | 1 | [`references/01-plan-and-scaffold.md`](references/01-plan-and-scaffold.md) | **Phase 1.** The gem vs project-private packaging split, directory trees for both, gemspec template, project-private path-gem / `RUBYLIB` activation, the `Rigor::Plugin::Base` skeleton, `.rigor.yml` `plugins:` wiring. |
-| 2 | [`references/02-walker-and-types.md`](references/02-walker-and-types.md) | **Phase 2.** The `node_rule` engine-owned AST walk over Prism nodes, the `Base#diagnostic` helper, asking the analyzer for inferred types via `scope.type_of`, two-pass / lexical context (`node_file_context` / `NodeContext`), the optional `dynamic_return` / `type_specifier` return-type hooks (`flow_contribution_for` was removed pre-1.0 in ADR-52 WD3), calling the target library's pure methods directly rather than reimplementing them (ADR-39: `Plugin::Inflector` over the real `ActiveSupport::Inflector`; `Base.suggest` for did-you-mean), and shipping `sig/*.rbs` so the DSL's types are visible. |
+| 2 | [`references/02-walker-and-types.md`](references/02-walker-and-types.md) | **Phase 2.** The `node_rule` engine-owned AST walk over Prism nodes, the `Base#diagnostic` helper, asking the analyzer for inferred types via `scope.type_of`, two-pass / lexical context (`node_file_context` / `NodeContext`), the optional `dynamic_return` / `narrowing_facts` return-type hooks (`narrowing_facts` was renamed from `type_specifier` in ADR-80, alias removed in 0.3.0; `flow_contribution_for` was removed pre-1.0 in ADR-52 WD3), calling the target library's pure methods directly rather than reimplementing them (ADR-39: `Plugin::Inflector` over the real `ActiveSupport::Inflector`; `Base.suggest` for did-you-mean), and shipping `sig/*.rbs` so the DSL's types are visible. |
 | 3 | [`references/03-test-and-ship.md`](references/03-test-and-ship.md) | **Phase 3.** Testing a plugin from outside the monorepo — fixture projects driven through `rigor check --format json`, plus pure unit tests of dispatch tables — with RSpec or Minitest. Version pinning against the pre-1.0 contract. README. Publishing to RubyGems or keeping the plugin private. |

data/skills/rigor-plugin-author/references/02-walker-and-types.md

@@ -162,7 +162,7 @@ rather than hand-rolling Levenshtein:
 Rigor::Plugin::Base.suggest(typo, known_names)  # nearest match, or nil
 ```
 
-## Optional — contribute a return type with `dynamic_return` / `type_specifier`
+## Optional — contribute a return type with `dynamic_return` / `narrowing_facts`
 
 > **Critical — these hooks do NOT make a method "defined", so they do
 > NOT suppress `call.undefined-method`.** Method *existence* and call
@@ -197,11 +197,15 @@ end
 # Post-return NARROWING FACTS, gated on the call's method name.
 # Return an Array of facts (or nil). Used for assertion / predicate
 # narrowing (`assert_kind_of(Foo, x)` ⇒ x is Foo afterwards).
-type_specifier methods: [:assert_kind_of] do |call_node, scope|
+narrowing_facts methods: [:assert_kind_of] do |call_node, scope|
   # ... build and return the post-return facts ...
 end
 ```
 
+> **`narrowing_facts` was renamed from `type_specifier` in ADR-80.**
+> `type_specifier` remains as a deprecating alias, removed in 0.3.0 — use
+> `narrowing_facts` in new plugins.
+
 Build return types with `Rigor::Type::Combinator`:
 
 ```ruby
@@ -240,7 +244,7 @@ If the DSL introduces methods or classes that Rigor cannot see (a
 Rigor RBS declaring them so *core* inference — not just your plugin —
 treats them as **defined**. This is what removes the
 `call.undefined-method` diagnostics on those methods; nothing else
-(not a `node_rule`, not `dynamic_return` / `type_specifier`) makes a
+(not a `node_rule`, not `dynamic_return` / `narrowing_facts`) makes a
 method exist in Rigor's view.
 
 Two ways to wire the RBS, depending on how the plugin is packaged:
@@ -288,6 +292,6 @@ They compose — many plugins ship both.
 
 A plugin whose `node_rule`(s) recognise the DSL and emit diagnostics
 with correct severities and rule ids — optionally a `dynamic_return` /
-`type_specifier` and a `sig/` bundle. Verify by eye with `rigor check`;
+`narrowing_facts` and a `sig/` bundle. Verify by eye with `rigor check`;
 lock it down with tests in Phase 3
 ([`03-test-and-ship.md`](03-test-and-ship.md)).

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rigortype
 version: !ruby/object:Gem::Version
-  version: 0.2.5
+  version: 0.2.6
 platform: ruby
 authors:
 - Rigor contributors
@@ -460,6 +460,7 @@ files:
 - lib/rigor/cli/annotate_command.rb
 - lib/rigor/cli/baseline_command.rb
 - lib/rigor/cli/check_command.rb
+- lib/rigor/cli/check_runner_factory.rb
 - lib/rigor/cli/ci_detector.rb
 - lib/rigor/cli/command.rb
 - lib/rigor/cli/coverage_command.rb
@@ -470,6 +471,7 @@ files:
 - lib/rigor/cli/diagnostic_formats.rb
 - lib/rigor/cli/diff_command.rb
 - lib/rigor/cli/docs_command.rb
+- lib/rigor/cli/doctor_command.rb
 - lib/rigor/cli/explain_command.rb
 - lib/rigor/cli/fused_protection_renderer.rb
 - lib/rigor/cli/fused_protection_report.rb
@@ -498,6 +500,7 @@ files:
 - lib/rigor/cli/type_scan_command.rb
 - lib/rigor/cli/type_scan_renderer.rb
 - lib/rigor/cli/type_scan_report.rb
+- lib/rigor/cli/upgrade_command.rb
 - lib/rigor/config_audit.rb
 - lib/rigor/configuration.rb
 - lib/rigor/configuration/dependencies.rb
@@ -547,6 +550,7 @@ files:
 - lib/rigor/inference/closure_escape_analyzer.rb
 - lib/rigor/inference/coverage_scanner.rb
 - lib/rigor/inference/def_return_typer.rb
+- lib/rigor/inference/dynamic_origin.rb
 - lib/rigor/inference/expression_typer.rb
 - lib/rigor/inference/fallback.rb
 - lib/rigor/inference/fallback_tracer.rb