rigortype 0.1.16 → 0.1.18

data/lib/rigor/inference/statement_evaluator.rb

@@ -476,31 +476,19 @@ module Rigor
       # carriers like `Nominal[Integer]` (Integer is always truthy
       # in Ruby — including 0) also collapse the dead else.
       def live_branch_for_if(node, pred_type, post_pred)
-        case predicate_certainty(pred_type)
-        when :always_truthy then eval_branch_or_nil(node.statements, post_pred)
-        when :always_falsey then eval_branch_or_nil(node.subsequent, post_pred)
+        case Narrowing.predicate_certainty(pred_type)
+        when :truthy then eval_branch_or_nil(node.statements, post_pred)
+        when :falsey then eval_branch_or_nil(node.subsequent, post_pred)
         end
       end
 
       def live_branch_for_unless(node, pred_type, post_pred)
-        case predicate_certainty(pred_type)
-        when :always_truthy then eval_branch_or_nil(node.else_clause, post_pred)
-        when :always_falsey then eval_branch_or_nil(node.statements, post_pred)
+        case Narrowing.predicate_certainty(pred_type)
+        when :truthy then eval_branch_or_nil(node.else_clause, post_pred)
+        when :falsey then eval_branch_or_nil(node.statements, post_pred)
         end
       end
 
-      def predicate_certainty(pred_type)
-        return nil if pred_type.nil? || pred_type.is_a?(Type::Bot)
-
-        truthy_bot = Narrowing.narrow_truthy(pred_type).is_a?(Type::Bot)
-        falsey_bot = Narrowing.narrow_falsey(pred_type).is_a?(Type::Bot)
-
-        return :always_falsey if truthy_bot && !falsey_bot
-        return :always_truthy if !truthy_bot && falsey_bot
-
-        nil
-      end
-
       def eval_else(node)
         return [Type::Combinator.constant_of(nil), scope] if node.statements.nil?
 
@@ -528,26 +516,76 @@ module Rigor
         results = []
         falsey_scope = entry_scope
         conditions.each do |branch|
+          # ADR-47 WD2 — record the scope ENTERING this clause (the
+          # subject narrowed by every earlier clause's negation) on the
+          # clause's first condition node, so `flow.unreachable-clause`
+          # can tell a prior-exhausted subject (entry already `bot`)
+          # from a per-clause-disjoint one (entry concrete, this clause
+          # disjoint). `on_enter`-only (no recursion) so no condition
+          # sub-expression is newly typed; `propagate` preserves the
+          # entry because it already keys the node.
+          record_clause_entry_scope(branch, falsey_scope)
           body_scope, falsey_scope = branch_body_and_falsey_scopes(subject, branch, falsey_scope)
           results << sub_eval(branch, body_scope)
         end
         [results, falsey_scope]
       end
 
+      # ADR-47 WD2/WD3 — record the scope ENTERING a `when`/`in` clause on
+      # the node `flow.unreachable-clause` reads to classify a dead clause
+      # (`when`: first condition; `in`: the pattern). `on_enter`-only so no
+      # sub-expression is newly typed; `propagate` preserves it.
+      def record_clause_entry_scope(branch, entry_scope)
+        node =
+          case branch
+          when Prism::WhenNode then branch.conditions.first
+          when Prism::InNode then branch.pattern
+          end
+        @on_enter&.call(node, entry_scope) if node
+      end
+
       # Returns `[body_scope, updated_falsey_scope]` for a single branch.
-      # `InNode` branches apply pattern bindings; `WhenNode` branches
-      # narrow through `Narrowing.case_when_scopes`. The falsey scope is
-      # unchanged for `in` branches (conservative: no exhaustiveness
-      # tracking yet).
+      # `WhenNode` branches narrow through `Narrowing.case_when_scopes`.
+      # `InNode` branches narrow soundly only for a bare class pattern
+      # (`in C` / `in C => x`, pure `is_a?`); every other pattern keeps
+      # the conservative "body = entry + bindings, falsey unchanged" shape.
       def branch_body_and_falsey_scopes(subject, branch, falsey_scope)
         if branch.is_a?(Prism::InNode)
-          [apply_in_pattern_bindings(subject, branch.pattern, falsey_scope), falsey_scope]
+          in_branch_body_and_falsey_scopes(subject, branch, falsey_scope)
         else
           when_conditions = branch.respond_to?(:conditions) ? branch.conditions : []
           Narrowing.case_when_scopes(subject, when_conditions, falsey_scope)
         end
       end
 
+      # ADR-47 WD3a — a bare class pattern matches on `C === subject`, i.e.
+      # exactly `subject.is_a?(C)` with no deconstruction, so it narrows
+      # like `when C`: the body sees the subject narrowed to `C` and the
+      # next clause's falsey scope has `C` removed. Other patterns can fail
+      # to match even when a class test would pass (deconstruction arity,
+      # hash keys, ...), so removing anything from the falsey scope would
+      # be unsound — they keep the conservative shape.
+      def in_branch_body_and_falsey_scopes(subject, branch, falsey_scope)
+        class_node = bare_class_pattern_node(branch.pattern)
+        return [apply_in_pattern_bindings(subject, branch.pattern, falsey_scope), falsey_scope] unless class_node
+
+        truthy_scope, narrowed_falsey = Narrowing.case_when_scopes(subject, [class_node], falsey_scope)
+        [apply_in_pattern_bindings(subject, branch.pattern, truthy_scope), narrowed_falsey]
+      end
+
+      # The class-constant node of a `in C` / `in C => x` pattern (the only
+      # `in` shapes whose match is pure `is_a?`), or nil for any pattern
+      # that deconstructs, binds, or matches a value.
+      def bare_class_pattern_node(pattern)
+        case pattern
+        when Prism::ConstantReadNode, Prism::ConstantPathNode
+          pattern
+        when Prism::CapturePatternNode
+          value = pattern.value
+          value if value.is_a?(Prism::ConstantReadNode) || value.is_a?(Prism::ConstantPathNode)
+        end
+      end
+
       def eval_case_else(else_clause, falsey_scope)
         return sub_eval(else_clause, falsey_scope) if else_clause
 
@@ -1371,22 +1409,47 @@ module Rigor
         end
       end
 
-      # ADR-37 slice 2 — gathers each plugin's post-return narrowing from
-      # BOTH the narrow `type_specifier` DSL (method-gated, wrapped as a
-      # facts-only `FlowContribution`) and the legacy
-      # `flow_contribution_for` escape valve, swallowing per-plugin
+      # ADR-37 slice 2 / ADR-52 WD3 — gathers each plugin's post-return
+      # narrowing from the method-gated `type_specifier` 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
+
+      # Per-dispatch collection of plugin narrowing contributions. Mirrors
+      # `MethodDispatcher#collect_plugin_contributions`: visit only the
+      # registry-ordered subset of plugins that implement a per-call path
+      # (`for_statement` = declares a `type_specifier`), gate each path
+      # by membership AND by the ADR-52 WD1 method-name gates (every
+      # `type_specifier` rule is `methods:`-gated, so the common
+      # no-candidate case is a single Set probe; a pruned
+      # consultation could only have returned `[]`), and accumulate
+      # lazily (shared frozen empty array otherwise). Same contributions in
+      # the same order as visiting every plugin; the caller is read-only.
       def collect_plugin_contributions(registry, call_node, current_scope)
-        registry.plugins.flat_map do |plugin|
-          contributions = []
-          legacy = plugin.flow_contribution_for(call_node: call_node, scope: current_scope)
-          contributions << legacy if legacy.is_a?(Rigor::FlowContribution)
+        index = registry.contribution_index
+        relevant = index.for_statement
+        return EMPTY_CONTRIBUTIONS if relevant.empty?
+
+        name = call_node.respond_to?(:name) ? call_node.name : nil
+        return EMPTY_CONTRIBUTIONS unless index.statement_candidate?(name)
+
+        collect_gated_statement_contributions(index, relevant, name, call_node, current_scope)
+      end
+
+      # The post-gate walk, in registry order — the same order the
+      # ungated walk used.
+      def collect_gated_statement_contributions(index, relevant, name, call_node, current_scope)
+        result = nil
+        relevant.each do |plugin|
+          next unless index.type_specifier_candidate_for?(plugin, name)
+
           facts = plugin.type_specifier_facts(call_node: call_node, scope: current_scope)
-          contributions << Rigor::FlowContribution.new(post_return_facts: facts) if facts && !facts.empty?
-          contributions
+          (result ||= []) << Rigor::FlowContribution.new(post_return_facts: facts) if facts && !facts.empty?
         rescue StandardError
-          []
+          next
         end
+        result || EMPTY_CONTRIBUTIONS
       end
 
       def resolve_call_method(call_node, current_scope)
@@ -1766,20 +1829,19 @@ module Rigor
       # ScopeIndexer-populated declaration overrides
       # (`Prism::ConstantReadNode` for `module Foo` headers, etc.)
       # remain reachable from inside nested bodies.
-      def build_fresh_body_scope # rubocop:disable Metrics/AbcSize
-        Scope.empty(environment: scope.environment)
-             .with_source_path(scope.source_path)
-             .with_declared_types(scope.declared_types)
-             .with_discovered_classes(scope.discovered_classes)
-             .with_in_source_constants(scope.in_source_constants)
-             .with_class_ivars(scope.class_ivars)
-             .with_class_cvars(scope.class_cvars)
-             .with_program_globals(scope.program_globals)
-             .with_discovered_methods(scope.discovered_methods)
-             .with_discovered_def_nodes(scope.discovered_def_nodes)
-             .with_discovered_superclasses(scope.discovered_superclasses)
-             .with_discovered_includes(scope.discovered_includes)
-             .with_discovered_method_visibilities(scope.discovered_method_visibilities)
+      def build_fresh_body_scope
+        # Single allocation instead of a deep `with_*` chain — this runs
+        # per class/method body on the main walk, so the chain's throwaway
+        # intermediate Scopes were a top `Scope#rebuild` source (ADR-44).
+        # Local-empty by design; the discovery index is inherited whole by
+        # reference (ADR-53 Track A), so a table added to the index can no
+        # longer be dropped here by a missed per-field copy.
+        Scope.new(
+          environment: scope.environment,
+          locals: {}.freeze,
+          source_path: scope.source_path,
+          discovery: scope.discovery
+        )
       end
 
       def singleton_def?(def_node)

data/lib/rigor/language_server/buffer_resolution.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative "uri"
+
+module Rigor
+  module LanguageServer
+    # Shared buffer lookup for the LSP providers.
+    #
+    # Every provider's `provide` opens with the same two steps: translate
+    # the document URI to an on-disk path, then fetch the open buffer
+    # entry from the buffer table — returning nil to the editor when
+    # either is missing. The parse step that follows differs per provider
+    # (strict vs error-tolerant, whole-buffer vs cursor-recovery), so
+    # only this resolution is shared here.
+    module BufferResolution
+      private
+
+      # Resolves `[path, entry]` for the document `uri`, or nil when the
+      # uri has no file path or no open buffer. A caller that destructures
+      # `path, entry = buffer_for(uri)` can guard on `entry.nil?` to cover
+      # both misses (a nil return leaves both locals nil).
+      def buffer_for(uri)
+        path = Uri.to_path(uri)
+        return nil if path.nil?
+
+        entry = @buffer_table[uri]
+        return nil if entry.nil?
+
+        [path, entry]
+      end
+    end
+  end
+end

data/lib/rigor/language_server/completion_provider.rb

@@ -3,6 +3,7 @@
 require "prism"
 
 require_relative "uri"
+require_relative "buffer_resolution"
 require_relative "../environment"
 require_relative "../reflection"
 require_relative "../scope"
@@ -35,6 +36,8 @@ module Rigor
     #
     # Slice 6 will add 7 (Class), 9 (Module), 21 (Constant).
     class CompletionProvider # rubocop:disable Metrics/ClassLength
+      include BufferResolution
+
       KIND_METHOD   = 2
       KIND_FIELD    = 5
       KIND_CLASS    = 7
@@ -54,10 +57,7 @@ module Rigor
       #   means "we tried and got nothing".
       def provide(uri:, line:, character:, trigger_character: nil)
         _ = trigger_character # Trigger info logged-not-routed in v1.
-        path = Uri.to_path(uri)
-        return nil if path.nil?
-
-        entry = @buffer_table[uri]
+        path, entry = buffer_for(uri)
         return nil if entry.nil?
 
         # Slice B4 — parse recovery. The common mid-edit buffer

data/lib/rigor/language_server/document_symbol_provider.rb

@@ -3,6 +3,7 @@
 require "prism"
 
 require_relative "uri"
+require_relative "buffer_resolution"
 
 module Rigor
   module LanguageServer
@@ -18,6 +19,8 @@ module Rigor
     # - Method      (6)  — `def m` inside a class / module
     # - Function    (12) — `def m` at top-level (no enclosing class)
     class DocumentSymbolProvider
+      include BufferResolution
+
       KIND_MODULE   = 2
       KIND_CLASS    = 5
       KIND_METHOD   = 6
@@ -33,10 +36,7 @@ module Rigor
       #   doesn't parse cleanly enough to surface symbols — LSP
       #   clients fall back to no-outline in that case.
       def provide(uri)
-        path = Uri.to_path(uri)
-        return nil if path.nil?
-
-        entry = @buffer_table[uri]
+        path, entry = buffer_for(uri)
         return nil if entry.nil?
 
         parse_result = Prism.parse(entry.bytes, filepath: path,

data/lib/rigor/language_server/folding_range_provider.rb

@@ -3,6 +3,7 @@
 require "prism"
 
 require_relative "uri"
+require_relative "buffer_resolution"
 
 module Rigor
   module LanguageServer
@@ -18,6 +19,8 @@ module Rigor
     # collapsed view shows the opener intact and hides the body
     # only.
     class FoldingRangeProvider
+      include BufferResolution
+
       def initialize(buffer_table:, project_context:)
         @buffer_table = buffer_table
         @project_context = project_context
@@ -26,10 +29,7 @@ module Rigor
       # @return [Array<Hash>, nil] LSP `FoldingRange[]` for the
       #   buffer, or nil when the URI isn't open / parseable.
       def provide(uri)
-        path = Uri.to_path(uri)
-        return nil if path.nil?
-
-        entry = @buffer_table[uri]
+        path, entry = buffer_for(uri)
         return nil if entry.nil?
 
         parse_result = Prism.parse(entry.bytes, filepath: path,

data/lib/rigor/language_server/hover_provider.rb

@@ -3,6 +3,7 @@
 require "prism"
 
 require_relative "uri"
+require_relative "buffer_resolution"
 require_relative "hover_renderer"
 require_relative "../environment"
 require_relative "../scope"
@@ -22,6 +23,8 @@ module Rigor
     #   for ASCII source (UTF-16 conversion is queued, see design
     #   doc § "Open questions").
     class HoverProvider
+      include BufferResolution
+
       def initialize(buffer_table:, project_context:, renderer: HoverRenderer.new)
         @buffer_table = buffer_table
         @project_context = project_context
@@ -33,10 +36,7 @@ module Rigor
       #   maps to `result: null` per the LSP spec — clients
       #   suppress the hover popup in that case.
       def provide(uri:, line:, character:)
-        path = Uri.to_path(uri)
-        return nil if path.nil?
-
-        entry = @buffer_table[uri]
+        path, entry = buffer_for(uri)
         return nil if entry.nil?
 
         parse_result = Prism.parse(entry.bytes, filepath: path, version: @project_context.configuration.target_ruby)

data/lib/rigor/language_server/selection_range_provider.rb

@@ -3,6 +3,7 @@
 require "prism"
 
 require_relative "uri"
+require_relative "buffer_resolution"
 
 module Rigor
   module LanguageServer
@@ -13,6 +14,8 @@ module Rigor
     # one keystroke moves up the chain, another moves further out,
     # all the way to the root.
     class SelectionRangeProvider
+      include BufferResolution
+
       def initialize(buffer_table:, project_context:)
         @buffer_table = buffer_table
         @project_context = project_context
@@ -23,10 +26,7 @@ module Rigor
       # @return [Array<Hash>, nil] one `SelectionRange` per
       #   position, or nil when the URI / buffer isn't resolvable.
       def provide(uri, positions)
-        path = Uri.to_path(uri)
-        return nil if path.nil?
-
-        entry = @buffer_table[uri]
+        path, entry = buffer_for(uri)
         return nil if entry.nil?
 
         parse_result = Prism.parse(entry.bytes, filepath: path,

data/lib/rigor/language_server/signature_help_provider.rb

@@ -3,6 +3,7 @@
 require "prism"
 
 require_relative "uri"
+require_relative "buffer_resolution"
 require_relative "../environment"
 require_relative "../reflection"
 require_relative "../scope"
@@ -35,6 +36,8 @@ module Rigor
     # active-parameter override per overload land in follow-up
     # slices (queued in the design doc § "Out of scope for v2").
     class SignatureHelpProvider
+      include BufferResolution
+
       ARG_SENTINEL = "__rigor_lsp_arg_sentinel__"
       private_constant :ARG_SENTINEL
 
@@ -47,10 +50,7 @@ module Rigor
       #   when the cursor isn't inside a resolvable method call.
       def provide(uri:, line:, character:, context: nil)
         _ = context # Trigger info accepted but not routed in v1.
-        path = Uri.to_path(uri)
-        return nil if path.nil?
-
-        entry = @buffer_table[uri]
+        path, entry = buffer_for(uri)
         return nil if entry.nil?
 
         bytes, locate_at = parse_attempt_bytes(entry.bytes, line, character)

data/lib/rigor/plugin/additional_initializer.rb

@@ -3,32 +3,40 @@
 module Rigor
   module Plugin
     # ADR-38 declaration: "on `receiver_constraint` (and its
-    # subclasses), every method named in `methods` also establishes
-    # instance-variable state — treat it like `initialize` for the
-    # read-before-write nil soundness gate."
+    # subclasses), every method named in `methods` (def-form) or
+    # `block_methods` (block-form) also establishes instance-variable
+    # state — treat it like `initialize` for the read-before-write nil
+    # soundness gate."
+    #
+    # **Def-form** (`methods:`) — applies when the ivar write lives in a
+    # named `def` body. Example: Minitest `def setup; @conn = …; end`.
+    #
+    # **Block-form** (`block_methods:`) — applies when the ivar write
+    # lives in a block passed to a method call. Example: RSpec
+    # `before { @user = create(:user) }` / `let(:x) { @y = … }`.
+    # `ScopeIndexer` descends the block body of any `CallNode` whose
+    # method name is in `block_methods`, collecting ivar writes exactly
+    # as it would for a def-form initializer.
+    #
+    # At least one of `methods:` or `block_methods:` must be non-empty.
     #
     # Authored on a plugin manifest:
     #
-    #   manifest(
-    #     id: "minitest",
-    #     version: "0.1.0",
-    #     additional_initializers: [
-    #       Rigor::Plugin::AdditionalInitializer.new(
-    #         receiver_constraint: "Minitest::Test",
-    #         methods: [:setup]
-    #       )
-    #     ]
+    #   # def-form (Minitest):
+    #   AdditionalInitializer.new(
+    #     receiver_constraint: "Minitest::Test",
+    #     methods: [:setup]
+    #   )
+    #
+    #   # block-form (RSpec):
+    #   AdditionalInitializer.new(
+    #     receiver_constraint: "RSpec::ExampleGroup",
+    #     block_methods: [:before, :let, :subject]
     #   )
     #
     # The Ruby analogue of PHPStan's `AdditionalConstructorsExtension`.
     # `Rigor::Inference::ScopeIndexer` consults the aggregated set at
-    # its single read-before-write gate: for a `def` whose name is in
-    # `methods` on a class that equals or inherits from
-    # `receiver_constraint` (matched via `Environment#class_ordering`,
-    # the same mechanism ADR-16 Tier A uses), the method's ivar writes
-    # are folded into the class's `init_writes` set, so a sibling
-    # method reading those ivars no longer gets a `Constant[nil]`
-    # widening.
+    # its read-before-write gate.
     #
     # The contribution can only ever *suppress* a nil widening — it
     # never makes the analyzer stricter — so a missed or over-broad
@@ -39,38 +47,47 @@ module Rigor
     #
     # - `receiver_constraint` — fully-qualified class name (String).
     #   The entry applies to that class and its subclasses.
-    # - `methods` — Array of Symbol method names treated as
-    #   initializers on a matching class.
+    # - `methods` — Array of Symbol `def`-form method names (may be
+    #   empty when only block_methods is used).
+    # - `block_methods` — Array of Symbol call-with-block method names
+    #   (may be empty when only methods is used).
     #
     # ## Ractor-shareability
     #
-    # Both fields are frozen at construction (ADR-15 Phase 1);
-    # `Ractor.shareable?` returns true after `#initialize`, so the
-    # value object survives `Plugin::Registry.materialize` into a
-    # worker Ractor.
+    # All fields are frozen at construction (ADR-15 Phase 1);
+    # `Ractor.shareable?` returns true after `#initialize`.
     class AdditionalInitializer
-      attr_reader :receiver_constraint, :methods
+      attr_reader :receiver_constraint, :methods, :block_methods
 
-      def initialize(receiver_constraint:, methods:)
+      def initialize(receiver_constraint:, methods: [], block_methods: [])
         validate_receiver_constraint!(receiver_constraint)
-        validate_methods!(methods)
+        validate_method_list!(methods, :methods)
+        validate_method_list!(block_methods, :block_methods)
+        validate_at_least_one!(methods, block_methods)
 
         @receiver_constraint = receiver_constraint.dup.freeze
         @methods = methods.map(&:to_sym).freeze
+        @block_methods = block_methods.map(&:to_sym).freeze
         freeze
       end
 
-      # True when `method_name` (a Symbol) is declared an initializer
-      # by this entry. The class-constraint match is the caller's
-      # responsibility (it needs the environment's class graph).
+      # True when `method_name` (a Symbol) is declared a def-form
+      # initializer by this entry.
       def covers_method?(method_name)
         methods.include?(method_name)
       end
 
+      # True when `method_name` (a Symbol) is declared a block-form
+      # initializer by this entry.
+      def covers_block_method?(method_name)
+        block_methods.include?(method_name)
+      end
+
       def to_h
         {
           "receiver_constraint" => receiver_constraint,
-          "methods" => methods.map(&:to_s)
+          "methods" => methods.map(&:to_s),
+          "block_methods" => block_methods.map(&:to_s)
         }
       end
 
@@ -93,16 +110,22 @@ module Rigor
               "got #{value.inspect}"
       end
 
-      def validate_methods!(value)
-        if value.is_a?(Array) && !value.empty? &&
-           value.all? { |m| m.is_a?(Symbol) || (m.is_a?(String) && !m.empty?) }
-          return
-        end
+      def validate_method_list!(value, field)
+        return if value.is_a?(Array) &&
+                  value.all? { |m| m.is_a?(Symbol) || (m.is_a?(String) && !m.empty?) }
 
         raise ArgumentError,
-              "Plugin::AdditionalInitializer#methods must be a non-empty Array of " \
+              "Plugin::AdditionalInitializer##{field} must be an Array of " \
               "Symbol/non-empty String, got #{value.inspect}"
       end
+
+      def validate_at_least_one!(methods, block_methods)
+        return unless methods.empty? && block_methods.empty?
+
+        raise ArgumentError,
+              "Plugin::AdditionalInitializer requires at least one of methods: or block_methods: " \
+              "to be non-empty"
+      end
     end
   end
 end