rigortype 0.2.7 → 0.2.9

data/lib/rigor/inference/project_patched_scanner.rb

@@ -8,22 +8,17 @@ require_relative "../source/constant_path"
 
 module Rigor
   module Inference
-    # ADR-17 slice 2 — pre-pass scanner. Walks every file the user
-    # listed under `pre_eval:` and harvests every `def` /
-    # `def self.` declaration inside a class / module body into a
-    # {ProjectPatchedMethods} registry the dispatcher consults
-    # below the plugin tier.
+    # ADR-17 slice 2 — pre-pass scanner. Walks every file the user listed under `pre_eval:` and
+    # harvests every `def` / `def self.` declaration inside a class / module body into a
+    # {ProjectPatchedMethods} registry the dispatcher consults below the plugin tier.
     #
-    # The walker is intentionally a strict subset of
-    # {Rigor::Inference::ScopeIndexer}'s machinery: it only needs
-    # `class C; def m; end; end` shape recognition, not full
-    # inference. Parse errors degrade to a fail-soft `:warning`
-    # `pre-eval.parse-error` diagnostic accumulated alongside
-    # the registry; per ADR-17 § "Failure modes" a parse failure
-    # in a pre-eval file MUST NOT abort the rest of the run.
+    # The walker is intentionally a strict subset of {Rigor::Inference::ScopeIndexer}'s machinery: it
+    # only needs `class C; def m; end; end` shape recognition, not full inference. Parse errors degrade
+    # to a fail-soft `:warning` `pre-eval.parse-error` diagnostic accumulated alongside the registry;
+    # per ADR-17 § "Failure modes" a parse failure in a pre-eval file MUST NOT abort the rest of the run.
     module ProjectPatchedScanner
-      # Frozen scan outcome carrying the populated registry and
-      # the per-file warnings the runner emits at run start.
+      # Frozen scan outcome carrying the populated registry and the per-file warnings the runner emits
+      # at run start.
       class Result < Data.define(:registry, :diagnostics)
         def initialize(registry:, diagnostics: [])
           super(
@@ -35,18 +30,13 @@ module Rigor
 
       module_function
 
-      # @param paths [Array<String>] absolute paths to the
-      #   pre-eval files. The runner has already validated that
-      #   each path exists (slice-1 `pre-eval.file-not-found`
-      #   `:error` covers missing entries); the scanner does NOT
-      #   re-check existence.
-      # @param buffer [Rigor::Analysis::BufferBinding, nil]
-      #   editor-mode buffer binding. When set, the scanner reads
-      #   the buffer's physical bytes if a pre-eval entry matches
-      #   the logical path, so users editing a monkey-patch file
-      #   see the in-flight version in their analysis.
-      # @return [Result] the populated registry plus any
-      #   per-file warnings.
+      # @param paths [Array<String>] absolute paths to the pre-eval files. The runner has already
+      #   validated that each path exists (slice-1 `pre-eval.file-not-found` `:error` covers missing
+      #   entries); the scanner does NOT re-check existence.
+      # @param buffer [Rigor::Analysis::BufferBinding, nil] editor-mode buffer binding. When set, the
+      #   scanner reads the buffer's physical bytes if a pre-eval entry matches the logical path, so
+      #   users editing a monkey-patch file see the in-flight version in their analysis.
+      # @return [Result] the populated registry plus any per-file warnings.
       def scan(paths, buffer: nil)
         entries = []
         diagnostics = []
@@ -58,13 +48,10 @@ module Rigor
         )
       end
 
-      # ADR-17 § "Failure modes" — when two pre-eval entries
-      # declare the same `(class_name, method_name, kind)` triple,
-      # emit one `:info` `pre-eval.duplicate-declaration`
-      # diagnostic per collision. The registry's first-write-wins
-      # behaviour is unchanged; the diagnostic just makes the
-      # shadowing visible so users notice when a later patch
-      # is silently masked.
+      # ADR-17 § "Failure modes" — when two pre-eval entries declare the same `(class_name, method_name,
+      # kind)` triple, emit one `:info` `pre-eval.duplicate-declaration` diagnostic per collision. The
+      # registry's first-write-wins behaviour is unchanged; the diagnostic just makes the shadowing
+      # visible so users notice when a later patch is silently masked.
       def duplicate_declaration_diagnostics(entries)
         seen = {}
         entries.each_with_object([]) do |entry, acc|
@@ -129,10 +116,9 @@ module Rigor
       end
       private_class_method :parse_error_diagnostic
 
-      # Builds a diagnostic Hash-shape the runner translates to a
-      # `Rigor::Analysis::Diagnostic`. The scanner intentionally
-      # does NOT depend on the analysis layer (it's a pre-pass);
-      # the runner adapts at the call site.
+      # Builds a diagnostic Hash-shape the runner translates to a `Rigor::Analysis::Diagnostic`. The
+      # scanner intentionally does NOT depend on the analysis layer (it's a pre-pass); the runner
+      # adapts at the call site.
       def build_diagnostic(path:, line:, column:, severity:, rule:, message:)
         { path: path, line: line, column: column, severity: severity, rule: rule, message: message }
       end

data/lib/rigor/inference/protection_scanner.rb

@@ -1,22 +1,21 @@
 # frozen_string_literal: true
 
 require_relative "scope_indexer"
+require_relative "origin_lookup"
 require_relative "../source/node_walker"
 
 module Rigor
   module Inference
-    # ADR-63 Tier 1 — the static type-protection proxy. Walks every dispatch
-    # site (a method call with an explicit receiver) and classifies it by
-    # whether the receiver types to a concrete (non-`Dynamic`) type — i.e. a
-    # site where Rigor's call rules *can* bite (undefined-method / wrong-arity /
-    # argument-type-mismatch). A `Dynamic` / `Top` receiver (or a union with such
-    # an arm — gradually valid) is *unprotected*: Rigor is blind there, and a
-    # type annotation on it would buy real catching power.
+    # ADR-63 Tier 1 — the static type-protection proxy. Walks every dispatch site (a method call with an
+    # explicit receiver) and classifies it by whether the receiver types to a concrete (non-`Dynamic`)
+    # type — i.e. a site where Rigor's call rules *can* bite (undefined-method / wrong-arity /
+    # argument-type-mismatch). A `Dynamic` / `Top` receiver (or a union with such an arm — gradually
+    # valid) is *unprotected*: Rigor is blind there, and a type annotation on it would buy real catching
+    # power.
     #
-    # This is a sound UPPER BOUND on protection — a concrete receiver is
-    # necessary but not sufficient for a diagnostic to actually fire — and it is
-    # one `type_of` pass, so it runs interactively and in CI. The truth tier
-    # (does a diagnostic fire) is the phased mutation tier.
+    # This is a sound UPPER BOUND on protection — a concrete receiver is necessary but not sufficient
+    # for a diagnostic to actually fire — and it is one `type_of` pass, so it runs interactively and in
+    # CI. The truth tier (does a diagnostic fire) is the phased mutation tier.
     class ProtectionScanner
       # A single unprotected call site.
       Site = Data.define(:line, :receiver, :method_name, :dynamic_origin)
@@ -24,8 +23,8 @@ module Rigor
       FileResult = Data.define(:protected_count, :unprotected_count, :sites) do
         def total = protected_count + unprotected_count
 
-        # Protected ratio; a file with no dispatch sites is vacuously fully
-        # protected (nothing to get wrong).
+        # Protected ratio; a file with no dispatch sites is vacuously fully protected (nothing to get
+        # wrong).
         def ratio = total.zero? ? 1.0 : protected_count.to_f / total
       end
 
@@ -48,7 +47,7 @@ module Rigor
           if concrete_receiver?(receiver_type)
             protected_count += 1
           else
-            origin = scope.dynamic_origins[node.receiver]
+            origin = OriginLookup.origin_for(scope, node.receiver)
             sites << Site.new(
               line: node.location.start_line,
               receiver: safe_describe(receiver_type),
@@ -67,10 +66,9 @@ module Rigor
         node.is_a?(Prism::CallNode) && !node.receiver.nil?
       end
 
-      # A receiver Rigor can reason about: anything that is not `Dynamic` /
-      # `Top`, and (for a union) only when every arm is concrete — a single
-      # `Dynamic` arm makes the whole call gradually valid, so the rules stay
-      # silent there.
+      # A receiver Rigor can reason about: anything that is not `Dynamic` / `Top`, and (for a union)
+      # only when every arm is concrete — a single `Dynamic` arm makes the whole call gradually valid,
+      # so the rules stay silent there.
       def concrete_receiver?(type)
         case type
         when Type::Dynamic, Type::Top then false

data/lib/rigor/inference/rbs_type_translator.rb

@@ -8,45 +8,37 @@ module Rigor
   module Inference
     # Translates `RBS::Types::*` instances into `Rigor::Type` values.
     #
-    # Slice 4 phase 2d adds two pieces of generic plumbing:
-    # - `RBS::Types::ClassInstance` arguments are translated recursively
-    #   so `Array[Integer]` becomes `Nominal["Array", [Nominal["Integer"]]]`
-    #   (and `Hash[Symbol, Integer]` becomes `Nominal["Hash", [...]]`).
-    # - `RBS::Types::Variable` consults a caller-supplied substitution
-    #   map (`type_vars:`) keyed by the variable's RBS name. When the
-    #   variable is bound, the bound `Rigor::Type` is returned unchanged;
-    #   when it is not bound, the variable degrades to `Dynamic[Top]` so
-    #   uninstantiated generics keep their fail-soft behavior.
+    # Generic plumbing:
+    # - `RBS::Types::ClassInstance` arguments are translated recursively so `Array[Integer]` becomes
+    #   `Nominal["Array", [Nominal["Integer"]]]` (and `Hash[Symbol, Integer]` becomes
+    #   `Nominal["Hash", [...]]`).
+    # - `RBS::Types::Variable` consults a caller-supplied substitution map (`type_vars:`) keyed by the
+    #   variable's RBS name. When the variable is bound, the bound `Rigor::Type` is returned unchanged;
+    #   when it is not bound, the variable degrades to `Dynamic[Top]` so uninstantiated generics keep
+    #   their fail-soft behavior.
     #
-    # Slice 5 phase 1 maps tuples and records to their dedicated shape
-    # carriers:
-    # - `RBS::Types::Tuple` becomes `Rigor::Type::Tuple[...]` so the
-    #   arity and per-position element types survive the boundary.
-    # - `RBS::Types::Record` becomes an exact closed
-    #   `Rigor::Type::HashShape{...}`, carrying required and optional
-    #   fields intact.
-    # Element and value types are translated recursively under the
-    # caller's `self_type` / `instance_type` / `type_vars` context.
+    # Shape carriers:
+    # - `RBS::Types::Tuple` becomes `Rigor::Type::Tuple[...]` so the arity and per-position element
+    #   types survive the boundary.
+    # - `RBS::Types::Record` becomes an exact closed `Rigor::Type::HashShape{...}`, carrying required
+    #   and optional fields intact.
+    # Element and value types are translated recursively under the caller's `self_type` /
+    # `instance_type` / `type_vars` context.
     #
-    # Interface and intersection types still degrade to `Dynamic[Top]`;
-    # they are bound to acceptance and dispatch rules that Slice 5+
-    # will replace.
+    # Interface and intersection types still degrade to `Dynamic[Top]`; they are bound to acceptance
+    # and dispatch rules not yet implemented.
     #
-    # The optional `self_type:` and `instance_type:` arguments are the
-    # Rigor counterparts of RBS's `self` and `instance` tokens:
-    # - `self_type` substitutes for `Bases::Self`. Inside an instance
-    #   method body it is `Nominal[C]`; inside a singleton method body
-    #   it is `Singleton[C]`.
-    # - `instance_type` substitutes for `Bases::Instance` and is always
-    #   `Nominal[C]` regardless of which method body we are in.
-    # When either argument is omitted, the corresponding token degrades
-    # to Dynamic[Top].
+    # The optional `self_type:` and `instance_type:` arguments are the Rigor counterparts of RBS's
+    # `self` and `instance` tokens:
+    # - `self_type` substitutes for `Bases::Self`. Inside an instance method body it is `Nominal[C]`;
+    #   inside a singleton method body it is `Singleton[C]`.
+    # - `instance_type` substitutes for `Bases::Instance` and is always `Nominal[C]` regardless of which
+    #   method body we are in.
+    # When either argument is omitted, the corresponding token degrades to Dynamic[Top].
     module RbsTypeTranslator
-      # Hash-based dispatch keeps `translate` linear and dodges the
-      # bookkeeping costs of a 20-arm `case` (RuboCop AbcSize/CCN/Length
-      # all spike on that shape). Anonymous RBS-type subclasses are not
-      # expected; the table only maps the concrete leaf classes shipped
-      # by the `rbs` gem.
+      # Hash-based dispatch keeps `translate` linear and dodges the bookkeeping costs of a 20-arm `case`
+      # (RuboCop AbcSize/CCN/Length all spike on that shape). Anonymous RBS-type subclasses are not
+      # expected; the table only maps the concrete leaf classes shipped by the `rbs` gem.
       TRANSLATORS = {
         RBS::Types::Bases::Top => :translate_top,
         RBS::Types::Bases::Bottom => :translate_bot,
@@ -78,13 +70,11 @@ module Rigor
       class << self
         # @param rbs_type [RBS::Types::Bases::Base, RBS::Types::ClassInstance, ...]
         # @param self_type [Rigor::Type, nil] substitute for `Bases::Self`.
-        # @param instance_type [Rigor::Type, nil] substitute for
-        #   `Bases::Instance`. Defaults to `nil`, which degrades to
-        #   Dynamic[Top].
-        # @param type_vars [Hash{Symbol => Rigor::Type}] substitution map
-        #   for `Bases::Variable`. Keys are the RBS variable names (e.g.,
-        #   `:Elem`); values are Rigor types that replace the variable.
-        #   Variables that are not bound in the map degrade to Dynamic[Top].
+        # @param instance_type [Rigor::Type, nil] substitute for `Bases::Instance`. Defaults to `nil`,
+        #   which degrades to Dynamic[Top].
+        # @param type_vars [Hash{Symbol => Rigor::Type}] substitution map for `Bases::Variable`. Keys
+        #   are the RBS variable names (e.g., `:Elem`); values are Rigor types that replace the
+        #   variable. Variables that are not bound in the map degrade to Dynamic[Top].
         # @return [Rigor::Type]
         def translate(rbs_type, self_type: nil, instance_type: nil, type_vars: EMPTY_TYPE_VARS)
           handler = TRANSLATORS[rbs_type.class]
@@ -111,10 +101,9 @@ module Rigor
           Type::Combinator.constant_of(nil)
         end
 
-        # `bool` in RBS denotes `true | false`. We fold it to that union
-        # eagerly so downstream comparisons (e.g., `result == Constant[true]`)
-        # remain structural. Memoized at the module level because the
-        # union is value-equal across calls.
+        # `bool` in RBS denotes `true | false`. We fold it to that union eagerly so downstream
+        # comparisons (e.g., `result == Constant[true]`) remain structural. Memoized at the module
+        # level because the union is value-equal across calls.
         def translate_bool(_rbs_type, _self_type, _instance_type, _type_vars)
           BOOL_UNION
         end
@@ -149,10 +138,9 @@ module Rigor
           Type::Combinator.constant_of(rbs_type.literal)
         end
 
-        # Slice 4 phase 2d translates the type arguments recursively so
-        # `Array[Integer]` round-trips into `Nominal["Array", [Nominal["Integer"]]]`.
-        # Variables inside the args participate in substitution through
-        # the same `type_vars:` map.
+        # Translates the type arguments recursively so `Array[Integer]` round-trips into
+        # `Nominal["Array", [Nominal["Integer"]]]`. Variables inside the args participate in
+        # substitution through the same `type_vars:` map.
         def translate_class_instance(rbs_type, self_type, instance_type, type_vars)
           name = rbs_type.name.relative!.to_s
           translated_args = rbs_type.args.map do |arg|
@@ -161,10 +149,9 @@ module Rigor
           Type::Combinator.nominal_of(name, type_args: translated_args)
         end
 
-        # Slice 5 phase 1: preserve tuple precision through the
-        # boundary. Each positional element type is translated
-        # recursively under the caller's substitution context, and the
-        # resulting list is wrapped in a `Rigor::Type::Tuple`.
+        # Preserves tuple precision through the boundary. Each positional element type is translated
+        # recursively under the caller's substitution context, and the resulting list is wrapped in a
+        # `Rigor::Type::Tuple`.
         def translate_tuple(rbs_type, self_type, instance_type, type_vars)
           elements = rbs_type.types.map do |t|
             translate(t, self_type: self_type, instance_type: instance_type, type_vars: type_vars)
@@ -172,10 +159,9 @@ module Rigor
           Type::Combinator.tuple_of(*elements)
         end
 
-        # Slice 5: preserve hash-record precision through the boundary.
-        # RBS records use Symbol keys; the translator keeps them as
-        # Symbol keys on the resulting exact closed HashShape so
-        # erasure can round-trip back to `{ a: T, ?b: U }` syntax.
+        # Preserves hash-record precision through the boundary. RBS records use Symbol keys; the
+        # translator keeps them as Symbol keys on the resulting exact closed HashShape so erasure can
+        # round-trip back to `{ a: T, ?b: U }` syntax.
         def translate_record(rbs_type, self_type, instance_type, type_vars)
           pairs = rbs_type.fields.each_with_object({}) do |(key, value), acc|
             acc[key] = translate(value, self_type: self_type, instance_type: instance_type, type_vars: type_vars)
@@ -195,19 +181,16 @@ module Rigor
           Type::Combinator.nominal_of(Proc)
         end
 
-        # `singleton(Foo)` is the type of the constant `Foo` itself
-        # (the class object). With the dedicated Singleton type added in
-        # Slice 4 phase 2b, we map directly to `Singleton[Foo]`.
+        # `singleton(Foo)` is the type of the constant `Foo` itself (the class object). With the
+        # dedicated Singleton type, we map directly to `Singleton[Foo]`.
         def translate_class_singleton(rbs_type, _self_type, _instance_type, _type_vars)
           name = rbs_type.name.relative!.to_s
           Type::Combinator.singleton_of(name)
         end
 
-        # Slice 4 phase 2d. Looks up the variable's RBS name in the
-        # substitution map; bound variables are replaced inline, free
-        # variables degrade to Dynamic[Top]. We use `fetch` with a
-        # default rather than `[]` so a deliberate `nil` binding (a
-        # caller mistake) is never silently consumed.
+        # Looks up the variable's RBS name in the substitution map; bound variables are replaced
+        # inline, free variables degrade to Dynamic[Top]. We use `fetch` with a default rather than
+        # `[]` so a deliberate `nil` binding (a caller mistake) is never silently consumed.
         def translate_variable(rbs_type, _self_type, _instance_type, type_vars)
           type_vars.fetch(rbs_type.name) { Type::Combinator.untyped }
         end