rigortype 0.4.7 → 0.4.8

data/lib/rigor/inference/definer_resolution.rb

@@ -82,11 +82,16 @@ module Rigor
       # the entry's answer, as `[owner_name, value]` (the owner is part of the answer so that two worlds naming
       # different parents disagree). It is the override lints' parent read: the nearest project ancestor after the
       # class whose block answers.
+      #
+      # Issue #3156 — a class or module the project declares but whose Ruby body records no method, superclass or
+      # include (`module PMod; end`, `class AMid` / `end`) is an external entry on the chain, which only its RBS
+      # declaration speaks for. The override block answers from RBS, so such an entry is asked too, under the
+      # project name it resolves to (`ResolutionChain::Entry#declared_name`); an undeclared external is not.
       def override_answer(scope)
         lambda do |chain, from|
-          first_hit(chain, scope, from) do |entry|
-            value = yield(entry.name)
-            [entry.name, value] unless value.nil?
+          first_hit(chain, scope, from, askable_external: true) do |name|
+            value = yield(name)
+            [name, value] unless value.nil?
           end
         end
       end
@@ -331,17 +336,20 @@ module Rigor
         kind == :singleton ? [:singleton, method_name.to_sym] : method_name.to_sym
       end
 
-      def first_hit(chain, scope, from)
+      # The first entry at or after `from` whose block answers. The default answer functions are handed the project
+      # entry; the override one (`askable_external:`) is handed a name, and also asks an external entry the project
+      # declares.
+      def first_hit(chain, scope, from, askable_external: false)
         index = from - 1
         found = nil
         chain.search(scope, from) do |entry|
           index += 1
-          next if entry.external?
+          next unless (name = entry.external? ? askable_external && entry.declared_name(scope) : entry.name)
 
-          answer = yield(entry)
+          answer = yield(askable_external ? name : entry)
           next if answer.nil?
 
-          found = Hit.new(answer, entry.name, index, entry.side)
+          found = Hit.new(answer, name, index, entry.side)
         end
         found
       end

data/lib/rigor/inference/definers_index.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
-require_relative "../run_scoped_slots"
+require_relative "../typing_state"
+require_relative "../memo_audit"
 
 module Rigor
   module Inference
@@ -21,12 +22,32 @@ module Rigor
     module DefinersIndex
       # These thread slots are bounded, like `ExpressionTyper#method_definers_index`'s two ways. Each is a fixed
       # number of entries, replaced rather than accumulated: two `[merged, seed]` pairs (the last file's two def
-      # tables) and two seed indexes. The run that filled them releases them when it ends ({RunScopedSlots}, #2399),
+      # tables) and two seed indexes. The run that filled them releases them when it ends (run-scoped, #2399),
       # so a finished run keeps none of its seed tables or their indexes alive.
-      LAYERS_KEY = RunScopedSlots.register(:__rigor_definers_index_layers__)
-      SEED_INDEX_KEY = RunScopedSlots.register(:__rigor_definers_index_seed__)
-      SEED_INDEX_ALT_KEY = RunScopedSlots.register(:__rigor_definers_index_seed_alt__)
-      private_constant :LAYERS_KEY, :SEED_INDEX_KEY, :SEED_INDEX_ALT_KEY
+      #
+      # ADR-129 WD1 — all three are run-scoped Memos keyed on table identity. The layers say only which seed a merged
+      # table was built over, a shortcut: {.for} answers the same index owners, `Layered` or whole, so the answer is
+      # a function of the table alone. Each seed index is a pure function of its seed table.
+      #
+      # Each hit goes through `MemoAudit.check`: a `Layered` answer is compared, in {.canonical} form, with the table
+      # inverted whole, and a seed index with the seed inverted again. While an audit recomputation runs
+      # ({MemoAudit.suspended?}) the three are neither read nor written, so it inverts every table whole.
+      LAYERS = TypingState.memo(
+        :definers_index_layers,
+        run_scoped: true, audit: "definers index layers",
+        reason: "the seed each of the last two merged tables was built over; keyed on table identity"
+      )
+      SEED_INDEX = TypingState.memo(
+        :definers_index_seed,
+        run_scoped: true, audit: "definers index seed",
+        reason: "pure function of the seed table it keys on"
+      )
+      SEED_INDEX_ALT = TypingState.memo(
+        :definers_index_seed_alt,
+        run_scoped: true, audit: "definers index seed alt",
+        reason: "pure function of the seed table it keys on"
+      )
+      private_constant :LAYERS, :SEED_INDEX, :SEED_INDEX_ALT
 
       # A name's owners: the seed's, less the owners the file replaced, plus the replaced owners' own.
       class Layered
@@ -46,6 +67,9 @@ module Rigor
           owners = from_file.nil? ? from_seed : (from_seed || []) + from_file
           @answers[method_name] = owners.nil? || owners.empty? ? nil : owners
         end
+
+        # Every name some owner may define, for {DefinersIndex.canonical}.
+        def names = @seed_index.keys | @replaced_index.keys
       end
 
       module_function
@@ -53,13 +77,18 @@ module Rigor
       # Records that the final `merged` table was built over `seed`. The last two are kept (a file merges an
       # instance and a singleton table), replaced rather than accumulated.
       def record_layers(merged, seed)
-        previous = Thread.current[LAYERS_KEY]
-        Thread.current[LAYERS_KEY] = [[merged, seed], previous&.first].compact
+        return if MemoAudit.enabled? && MemoAudit.suspended?
+
+        state = TypingState.current
+        previous = state[LAYERS]
+        state[LAYERS] = [[merged, seed], previous&.first].compact
       end
 
       # The definers index over `table`.
       def for(table)
-        seed = Thread.current[LAYERS_KEY]&.find { |entry| entry[0].equal?(table) }&.last
+        return build(table) if MemoAudit.suspended?
+
+        seed = TypingState.current[LAYERS]&.find { |entry| entry[0].equal?(table) }&.last
         return build(table) if seed.nil? || !deeply_frozen?(seed)
 
         replaced = {}
@@ -73,7 +102,25 @@ module Rigor
         end
         return build(table) unless kept + replaced.count { |owner, _| seed.key?(owner) } == seed.size
 
-        Layered.new(seed_index(seed), replaced, build(replaced))
+        audit_layered(Layered.new(seed_index(seed), replaced, build(replaced)), table)
+      end
+
+      # `index`, after checking it against `table` inverted whole when the audit is on.
+      def audit_layered(index, table)
+        return index unless MemoAudit.enabled?
+
+        MemoAudit.check("definers index layers", canonical(index), table.size) { canonical(build(table)) }
+        index
+      end
+
+      # `index` as a plain `name → sorted owners` Hash, so a `Layered` index and a whole one compare equal when they
+      # hold the same owners. Audit-only: it reads every name.
+      def canonical(index)
+        names = index.is_a?(Layered) ? index.names : index.keys
+        names.each_with_object({}) do |name, out|
+          owners = index[name]
+          out[name] = owners.sort if owners
+        end
       end
 
       def deeply_frozen?(seed)
@@ -82,13 +129,22 @@ module Rigor
 
       # The seed's index, built once per seed table. Two ways, an instance and a singleton seed table.
       def seed_index(seed)
-        [SEED_INDEX_KEY, SEED_INDEX_ALT_KEY].each do |key|
-          slot = Thread.current[key]
-          return slot[1] if slot && slot[0].equal?(seed)
+        state = TypingState.current
+        slot = state[SEED_INDEX]
+        if slot && slot[0].equal?(seed)
+          return MemoAudit.check("definers index seed", slot[1], seed.size) do
+            build(seed)
+          end
         end
-        index = build(seed)
-        Thread.current[SEED_INDEX_ALT_KEY] = Thread.current[SEED_INDEX_KEY]
-        Thread.current[SEED_INDEX_KEY] = [seed, index]
+
+        slot = state[SEED_INDEX_ALT]
+        if slot && slot[0].equal?(seed)
+          return MemoAudit.check("definers index seed alt", slot[1], seed.size) { build(seed) }
+        end
+
+        index = MemoAudit.key_audit("definers index seed") { build(seed) }
+        state[SEED_INDEX_ALT] = state[SEED_INDEX]
+        state[SEED_INDEX] = [seed, index]
         index
       end
 

data/lib/rigor/inference/error_info.rb

@@ -37,6 +37,22 @@ module Rigor
 
       module_function
 
+      # The exception instance type a `RescueNode` binds its reference to: `StandardError` for a bare `rescue`, else
+      # the union over the named exceptions, each the instance of the class the block types it as (`yield`ed the
+      # exception node) or `Dynamic[top]` when that is not a `Singleton` (a splat list, an unresolved constant).
+      # Shared by `StatementEvaluator#rescue_exception_type` and the class-ivar census (issue #1217), so the two
+      # agree.
+      def rescue_exception_type(rescue_node)
+        exceptions = rescue_node.exceptions
+        return Type::Combinator.nominal_of("StandardError") if exceptions.empty?
+
+        types = exceptions.map do |exception_node|
+          type = yield(exception_node)
+          type.is_a?(Type::Singleton) ? Type::Combinator.nominal_of(type.class_name) : Type::Combinator.untyped
+        end
+        Type::Combinator.union(*types)
+      end
+
       # The scope a `rescue` clause, or a rescue modifier's fallback, runs from: `$!` bound to the exception it rescued
       # and `$@` to that exception's backtrace, with `$?` unbound. `exception_type` is what `rescue … => e` binds `e` to
       # (`StatementEvaluator#rescue_exception_type`): the union of the named classes' instances, `StandardError` for a