rigortype 0.4.3 → 0.4.5

data/plugins/rigor-rspec/lib/rigor/plugin/rspec/matcher_analyzer.rb

@@ -18,7 +18,8 @@ module Rigor
       #   Nominal[T] uniformly, so the distinction with `be_a` is observed at the carrier level but not the
       #   runtime).
       # - `be_nil` — narrows `x` to `Constant<nil>`.
-      # - `eq(LITERAL)` for a literal-value argument — narrows `x` to `Constant<literal>`.
+      # - `eq(LITERAL)` / `eql(LITERAL)` for a literal-value argument — meets `x` with `Constant<literal>`
+      #   (see "Equality is the local's own method" below).
       #
       # The matchers below this floor (`be_truthy` / `be_falsey` / `be_within` / `be > / < / >=` /
       # `include` / `start_with` / `match(regex)` / `raise_error` / receive-style mocks) require either
@@ -35,16 +36,47 @@ module Rigor
       #    fall through.
       # 3. The matcher is one of the recognised forms above (`be_a` / `be_kind_of` / `be_instance_of` /
       #    `be_an_instance_of` / `be_nil` / `eq(literal)` / `eql(literal)` / `match(/regex/)`).
+      #
+      # ## Equality is the local's own method
+      #
+      # `expect(x).to eq(lit)` passes when `x == lit` and `eql(lit)` when `x.eql?(lit)`: the local is the
+      # receiver, so its own `==` / `eql?` decides, and a class with a custom `==` can equal even a `nil`,
+      # boolean or Symbol literal. A positive equality fact therefore never replaces the local's type (issue
+      # #1807). It is a meet with the local's current type, member by member:
+      #
+      # - a member of the literal's own core class (`Integer`, `Float`, `String`, `Symbol`, `NilClass`,
+      #   `TrueClass`, `FalseClass`) narrows to the literal, a refinement of that class (`non-empty-string`,
+      #   `decimal-int-string`, `non-zero-int`) included; a `Constant` member is kept when it equals the
+      #   literal and dropped otherwise; a `Float` member meeting `0.0` (which `-0.0` also equals) is kept;
+      # - a core numeric member of another class (`Integer`, `Float`, `Rational`, `Complex`) is kept under
+      #   `eq` (`1.0 == 1`) and dropped under `eql` (`1.0.eql?(1)` is false);
+      # - any other core member (`nil` against `9`, a `String` against `:a`) is dropped: built-in equality
+      #   across those classes is false;
+      # - a member of a core class is kept unnarrowed when the project's source defines the operator on that
+      #   class or on a core ancestor up to the one that owns the operator at runtime (`class Symbol; def
+      #   ==`, `class Numeric; def eql?` for an `Integer`, `class Object; def ==` for `nil`): its own method
+      #   decides.
+      #
+      # When any member is `Dynamic` or of any other class (a user class, `Object`, `Numeric`, `BigDecimal`),
+      # the analyzer emits no fact and the local keeps its type. It also emits none when the project's source
+      # defines the operator on the literal's class or those ancestors of it — a core `==` calls back into the
+      # literal's (`Integer#==` runs `other == self` for a non-numeric argument, `String#==` for one that
+      # responds to `to_str`), so a custom one there can make any member equal — and for an unbound local,
+      # when no member survives, and without a scope. A reopening that defines other methods only
+      # (`class String; def shout`) does not count.
+      #
+      # The negative forms (`not_to` / `to_not`) still emit a negative `Constant` fact, which the engine's fact
+      # narrowing does not act on, so the local keeps its type there too.
       module MatcherAnalyzer
         module_function
 
         # @param call_node — the call whose contribution we're computing. Returns nil when
         #   the call shape does not match `expect(local).to matcher`.
-        # @param environment — the surrounding environment used to resolve a
-        #   matcher's class-name argument to a `Type::Nominal`. When nil, class-name resolution falls back
-        #   to a bare `Nominal[<name>]` carrier (sound — the receiver constant may be a user class not in
-        #   RBS).
-        def contribution_for(call_node, environment:)
+        # @param scope — the scope at the call, or nil. Its environment resolves a matcher's class-name
+        #   argument to a `Type::Nominal` (without one, a bare `Nominal[<name>]` carrier — sound, the receiver
+        #   constant may be a user class not in RBS); the local's current type in it is what a positive
+        #   `eq` / `eql` fact meets (without one, no such fact).
+        def contribution_for(call_node, scope:)
           verb = assertion_verb(call_node)
           return nil if verb.nil?
           return nil unless call_node.receiver.is_a?(Prism::CallNode)
@@ -58,14 +90,15 @@ module Rigor
           matcher = matcher_call(call_node)
           return nil if matcher.nil?
 
-          narrowed_type = narrowed_type_for(matcher, environment: environment)
+          negative = verb == :negative
+          narrowed_type = narrowed_type_for(matcher, target_local, negative: negative, scope: scope)
           return nil if narrowed_type.nil?
 
           fact = Rigor::FlowContribution::Fact.new(
             target_kind: :local,
             target_name: target_local,
             type: narrowed_type,
-            negative: verb == :negative
+            negative: negative
           )
           Rigor::FlowContribution.new(post_return_facts: [fact])
         end
@@ -105,7 +138,8 @@ module Rigor
         # narrowed type. Returns nil when the matcher is
         # unrecognised or its argument shape does not match the
         # supported envelope.
-        def narrowed_type_for(matcher, environment:)
+        def narrowed_type_for(matcher, target_local, negative:, scope:)
+          environment = scope&.environment
           return nil unless matcher.is_a?(Prism::CallNode) && matcher.receiver.nil?
 
           case matcher.name
@@ -116,7 +150,7 @@ module Rigor
 
             Rigor::Type::Combinator.constant_of(nil)
           when :eq, :eql
-            constant_type_for_literal_arg(matcher)
+            equality_type_for_literal_arg(matcher, target_local, negative: negative, scope: scope)
           when :match
             # `match(/regex/)` narrows x to String. `match("...")` or `match(arbitrary_object)` falls
             # through — the broader matcher dispatch needs the receiver to be a String, but we can only
@@ -140,14 +174,123 @@ module Rigor
           end
         end
 
-        def constant_type_for_literal_arg(matcher)
+        def equality_type_for_literal_arg(matcher, target_local, negative:, scope:)
           args = matcher.arguments&.arguments || []
           return nil unless args.size == 1
 
           literal_value = literal_value_for(args.first)
           return nil if literal_value.equal?(NO_LITERAL)
+          return Rigor::Type::Combinator.constant_of(literal_value) if negative
+          return nil if scope.nil?
+
+          operator = matcher.name == :eql ? :eql? : :==
+          equality_meet(scope.local(target_local), literal_value, operator, scope)
+        end
+
+        # --- equality meet (`eq` / `eql`; see "Equality is the local's own method") ---
+
+        # Core classes whose `==` / `eql?` Rigor can evaluate against a literal: across any two of them the
+        # answer is built in, unless the project defines the operator on one of them.
+        EQUALITY_CORE_CLASSES = [Integer, Float, Rational, Complex, String, Symbol, NilClass, TrueClass,
+                                 FalseClass].freeze
+        Ractor.make_shareable(EQUALITY_CORE_CLASSES)
+        private_constant :EQUALITY_CORE_CLASSES
+
+        NUMERIC_CLASS_NAMES = %w[Integer Float Rational Complex].freeze
+        Ractor.make_shareable(NUMERIC_CLASS_NAMES)
+        private_constant :NUMERIC_CLASS_NAMES
+
+        # For each core class and operator, the class and its ancestors up to and including the one that owns
+        # the operator at runtime (`Integer#eql?` is `Numeric`'s, `nil == x` is `BasicObject`'s). A project
+        # definition on any of them is the method the member runs; one above the owner is shadowed by it.
+        OPERATOR_OWNER_CHAINS = EQUALITY_CORE_CLASSES.each_with_object({}) do |klass, chains|
+          %i[== eql?].each do |operator|
+            ancestors = klass.ancestors
+            owner_index = ancestors.index(klass.instance_method(operator).owner)
+            chains[[klass.name, operator]] = ancestors[0..owner_index].map(&:name).freeze
+          end
+        end.freeze
+        Ractor.make_shareable(OPERATOR_OWNER_CHAINS)
+        private_constant :OPERATOR_OWNER_CHAINS
+
+        # Marks a member whose equality with the literal cannot be decided, so the whole meet gives up.
+        UNDECIDED = Object.new.freeze
+        private_constant :UNDECIDED
+
+        # The members of `current` that `x <operator> literal` admits, narrowed where the member's class is
+        # the literal's, or nil when any member is undecided or none survives. An unbound local (nil) is one
+        # undecided member.
+        def equality_meet(current, literal, operator, scope)
+          return nil if project_defines?(literal.class.name, operator, scope)
+
+          members = current.is_a?(Rigor::Type::Union) ? current.members : [current]
+          kept = []
+          members.each do |member|
+            met = meet_member(member, literal, operator, scope)
+            return nil if met.equal?(UNDECIDED)
 
-          Rigor::Type::Combinator.constant_of(literal_value)
+            kept << met unless met.nil?
+          end
+          return nil if kept.empty?
+
+          Rigor::Type::Combinator.union(*kept)
+        end
+
+        # One member's part of the meet: the member itself or its narrowing, nil when no value of it equals
+        # the literal, or UNDECIDED.
+        def meet_member(member, literal, operator, scope)
+          class_name = member_class_name(member)
+          return UNDECIDED if class_name.nil?
+          return member if project_defines?(class_name, operator, scope)
+
+          case member
+          when Rigor::Type::Constant then member.value.public_send(operator, literal) ? member : nil
+          when Rigor::Type::IntegerRange
+            literal.is_a?(Integer) && !member.covers?(literal) ? nil : meet_class(member, class_name, literal, operator)
+          else meet_class(member, class_name, literal, operator)
+          end
+        end
+
+        # The core class a member's values belong to, or nil for a member that is not wholly of one. A
+        # refinement (`Difference`, `Refined`) belongs to its base's class, an `Intersection` to the class all
+        # its members share.
+        def member_class_name(member)
+          case member
+          when Rigor::Type::Difference, Rigor::Type::Refined then member_class_name(member.base)
+          when Rigor::Type::Intersection
+            names = member.members.map { |part| member_class_name(part) }.uniq
+            names.size == 1 ? names.first : nil
+          when Rigor::Type::FloatRange then "Float"
+          when Rigor::Type::Constant
+            klass = EQUALITY_CORE_CLASSES.find { |core| member.value.instance_of?(core) }
+            klass&.name
+          when Rigor::Type::IntegerRange then "Integer"
+          when Rigor::Type::Nominal
+            name = member.class_name
+            member.type_args.empty? && EQUALITY_CORE_CLASSES.any? { |core| core.name == name } ? name : nil
+          end
+        end
+
+        def meet_class(member, class_name, literal, operator)
+          literal_class = literal.class.name
+          if class_name == literal_class
+            literal.is_a?(Float) && literal.zero? ? member : Rigor::Type::Combinator.constant_of(literal)
+          elsif NUMERIC_CLASS_NAMES.include?(class_name) && NUMERIC_CLASS_NAMES.include?(literal_class)
+            operator == :== ? member : nil
+          end
+        end
+
+        # Whether the project's source defines `operator` on the core class `class_name` or on a core ancestor
+        # up to the operator's runtime owner (OPERATOR_OWNER_CHAINS): a reopening's `def`, an included or
+        # prepended project module, a `define_method`. The def-node walk sees other files' `def`s and records
+        # the dependency on them; the discovery table adds `define_method`. An RBS declaration is not
+        # consulted: once the project reopens `String` for anything, `String#==`'s declaring owner is a
+        # project class, which says nothing about who wrote `==`.
+        def project_defines?(class_name, operator, scope)
+          OPERATOR_OWNER_CHAINS.fetch([class_name, operator]).any? do |name|
+            !scope.user_def_through_ancestors(name, operator).first.nil? ||
+              scope.discovered_method_through_ancestors?(name, operator, :instance)
+          end
         end
 
         def string_type_for_regex_arg(matcher)

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

@@ -86,7 +86,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.
       narrowing_facts methods: %i[to not_to to_not] do |call_node, scope|
-        MatcherAnalyzer.contribution_for(call_node, environment: scope&.environment)&.post_return_facts
+        MatcherAnalyzer.contribution_for(call_node, scope: scope)&.post_return_facts
       end
 
       # ADR-52 slice 5a — binds local reads in `it` / spec bodies to their `let(:name) { ... }` block's
@@ -98,13 +98,15 @@ module Rigor
         let_binding_return_type(call_node, scope)
       end
 
-      # ADR-88 WD1 — both contributions are per-file: the matcher narrowing facts come from the call's own AST,
-      # and the `let`-binding return types come from each spec file's OWN `describe`/`let` structure (`let` is
-      # file-scoped). A spec file's edit changes its own content (re-analysed already). The one cross-file input
-      # — the optional factorybot `:factory_index` fact this plugin consumes — is itself an ADR-9 publication
-      # captured in the incremental fact-surface digest via factorybot's own channel, so it need not appear
-      # here. A stable sentinel declares "no OWN cross-file fact surface", keeping the plugin
-      # incremental-capable; `--verify-incremental` backstops the claim.
+      # ADR-88 WD1 — both contributions are per-file: the matcher narrowing facts come from the call's own AST
+      # and, for `eq` / `eql`, from the local's current type and the scope's project discovery (whether the
+      # project defines `==` / `eql?` on a core class); the `let`-binding return types come from each spec
+      # file's OWN `describe`/`let` structure (`let` is file-scoped). A spec file's edit changes its own
+      # content (re-analysed already). The one cross-file input — the optional factorybot `:factory_index`
+      # fact this plugin consumes — is itself an ADR-9 publication captured in the incremental fact-surface
+      # digest via factorybot's own channel, so it need not appear here. A stable sentinel declares "no OWN
+      # cross-file fact surface", keeping the plugin incremental-capable; `--verify-incremental` backstops
+      # the claim.
       def incremental_state_fingerprint
         "per-file-lets"
       end

data/plugins/rigor-sidekiq/lib/rigor/plugin/sidekiq/worker_discoverer.rb

@@ -92,7 +92,7 @@ module Rigor
             # ADR-45 WD1b (#613) — boundary-probed: a root that appears later invalidates the warm run.
             next [] unless @io_boundary.directory?(absolute)
 
-            Dir.glob(File.join(absolute, "**", "*.rb"))
+            Dir.glob("**/*.rb", base: absolute).map { |path| File.join(absolute, path) }
           end
         end
 

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

@@ -29,7 +29,9 @@ module Rigor
     # ## Reach
     #
     # All nine class-level HTTP verb methods Sinatra exposes: `get`, `post`, `put`, `delete`, `head`,
-    # `options`, `patch`, `link`, `unlink` (`lib/sinatra/base.rb:1531-1553`). Both modular-style subclasses
+    # `options`, `patch`, `link`, `unlink` (`lib/sinatra/base.rb:1531-1553`), plus the `before` / `after`
+    # filters (`add_filter`) and the `error` / `not_found` handlers, whose blocks `compile!` turns into
+    # instance methods through the same `generate_method` (issue #1768). Both modular-style subclasses
     # of `Sinatra::Base` and `Sinatra::Application` (classic top-level style, when used via `class App <
     # Sinatra::Application`) match because the receiver constraint accepts every subclass.
     #
@@ -57,7 +59,7 @@ module Rigor
         block_as_methods: [
           Rigor::Plugin::Macro::BlockAsMethod.new(
             receiver_constraint: "Sinatra::Base",
-            method_names: %i[get post put delete head options patch link unlink]
+            method_names: %i[get post put delete head options patch link unlink before after error not_found]
           )
         ]
       )

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

@@ -504,8 +504,8 @@ module Rigor
             # must not vary by machine / run. `Dir.glob` sorts its results by default on Ruby 3.0+, so the fold
             # order is already stable (the slice-1 comment's "filesystem order" caveat predates that default);
             # this walk relies on it rather than re-sorting.
-            Dir.glob(File.join(absolute, "**", "*#{ext}")).each do |path|
-              harvest_file(canonicalize(path), catalog, sigil_by_path, parse_errors_by_path)
+            Dir.glob("**/*#{ext}", base: absolute).each do |relative|
+              harvest_file(canonicalize(File.join(absolute, relative)), catalog, sigil_by_path, parse_errors_by_path)
             end
           end
         elsif io_boundary.file?(absolute) && extensions.any? { |ext| absolute.end_with?(ext) }

data/plugins/rigor-typelizer/lib/rigor/plugin/typelizer/serializer_discoverer.rb

@@ -63,7 +63,7 @@ module Rigor
           @project_paths.flat_map do |entry|
             absolute = File.expand_path(entry)
             if @io_boundary.directory?(absolute)
-              Dir.glob(File.join(absolute, "**", "*.rb"))
+              Dir.glob("**/*.rb", base: absolute).map { |path| File.join(absolute, path) }
             elsif absolute.end_with?(".rb") && @io_boundary.file?(absolute)
               [absolute]
             else
@@ -78,7 +78,7 @@ module Rigor
             # ADR-45 WD1b (#613) — boundary-probed: a root that appears later invalidates the warm run.
             next [] unless @io_boundary.directory?(absolute)
 
-            Dir.glob(File.join(absolute, "**", "*.rb"))
+            Dir.glob("**/*.rb", base: absolute).map { |path| File.join(absolute, path) }
           end
         end
       end

data/sig/rigor/plugin/io_boundary.rbs

@@ -4,11 +4,14 @@ class Rigor::Plugin::IoBoundary
   def file?: (untyped) -> bool
   def directory?: (untyped) -> bool
   def list_directory: (untyped) -> Array[String]
+  def list_directory_kinds: (untyped) -> Hash[String, untyped]
   # Records a `:names` glob row (membership only); a caller needing a match's content `read_file`s it. A `..`
   # segment, a brace or a backslash in `pattern` raises `AccessDeniedError`.
   def glob: (untyped root, untyped pattern) -> Array[String]
-  # sig-gen gap: #1156 — the generator pins the empty-summary literal (`count: 0, first_path: nil`); the
-  # record's fields are the running count and the first refused path, nil when nothing was refused.
+  # sig-gen gap: #1154 — the proposal leaves both string fields untyped. `nearest_root` comes from `@policy`, an
+  # ivar assigned from an `initialize` parameter (the #1154 shape); `first_path` comes from `@first_refused_path`,
+  # written from `record_refusal(path)`'s parameter outside `initialize`, a case #1154 as titled does not yet cover.
+  # The record's fields are the running count and the first refused path, nil when nothing was refused.
   def refusal_summary: () -> { count: Integer, first_path: String?, nearest_root: String? }?
   def open_url: (untyped url) -> String
   # Returns a frozen `Rigor::Cache::Descriptor` (no RBS yet -> untyped).

data/sig/rigor/rooted_glob.rbs

@@ -0,0 +1,7 @@
+module Rigor
+  module RootedGlob
+    METACHARACTERS: Regexp
+
+    def self?.glob: (untyped, untyped) -> Array[String]
+  end
+end

data/sig/rigor/scope.rbs

@@ -61,7 +61,7 @@ module Rigor
     def discovered_singleton_def_nodes: () -> Hash[String, Hash[Symbol, untyped]]
     def discovered_def_sources: () -> Hash[String, Hash[Symbol, String]]
     def discovered_singleton_def_sources: () -> Hash[String, Hash[Symbol, String]]
-    def discovered_method_visibilities: () -> Hash[String, Hash[Symbol, Symbol]]
+    def discovered_method_visibilities: () -> Hash[String, Hash[Symbol | [:singleton, Symbol], Symbol]]
     # sig-gen gap: #1148 — sig-gen skips an endless-def reader (untyped return); the row is hand-written.
     def discovered_parameter_envelopes: () -> Hash[String, Hash[untyped, untyped]]
     # sig-gen gap: #1149 — sig-gen skips the `||` fallback reader (untyped return); the row is hand-written.
@@ -128,7 +128,7 @@ module Rigor
       attr_reader discovered_singleton_def_nodes: Hash[String, Hash[Symbol, untyped]]
       attr_reader discovered_def_sources: Hash[String, Hash[Symbol, String]]
       attr_reader discovered_singleton_def_sources: Hash[String, Hash[Symbol, String]]
-      attr_reader discovered_method_visibilities: Hash[String, Hash[Symbol, Symbol]]
+      attr_reader discovered_method_visibilities: Hash[String, Hash[Symbol | [:singleton, Symbol], Symbol]]
       # sig-gen gap: #1150 — `Data.define` members carry no type, as for every other row in this class.
       attr_reader discovered_parameter_envelopes: Hash[String, Hash[untyped, untyped]]
       attr_reader discovered_superclasses: Hash[String, String]
@@ -201,7 +201,7 @@ module Rigor
       # authored: ADR-119 WD1 sibling pairing; no inferred signature exists for it (#1150).
       def sibling_tables: () -> Hash[Symbol, untyped]
 
-      def with: (?declared_types: Hash[untyped, Type::t], ?class_ivars: Hash[String, Hash[Symbol, Type::t]], ?class_cvars: Hash[String, Hash[Symbol, Type::t]], ?program_globals: Hash[Symbol, Type::t], ?program_global_seeds: Hash[Symbol, Type::t], ?discovered_classes: Hash[String, Type::Singleton], ?in_source_constants: Hash[String, Type::t], ?discovered_methods: Hash[String, Hash[Symbol, Symbol]], ?discovered_def_nodes: Hash[String, Hash[Symbol, untyped]], ?discovered_def_nestings: Hash[untyped, Array[String]], ?discovered_singleton_def_nodes: Hash[String, Hash[Symbol, untyped]], ?discovered_def_sources: Hash[String, Hash[Symbol, String]], ?discovered_singleton_def_sources: Hash[String, Hash[Symbol, String]], ?discovered_method_visibilities: Hash[String, Hash[Symbol, Symbol]], ?discovered_parameter_envelopes: Hash[String, Hash[untyped, untyped]], ?discovered_superclasses: Hash[String, String], ?discovered_includes: Hash[String, Array[String]], ?discovered_prepends: Hash[String, Array[String]], ?discovered_extends: Hash[String, Array[String]], ?discovered_class_sources: Hash[String, Set[String]], ?constant_sources: Hash[String, Set[String]], ?constant_writers: Hash[String, Array[String]], ?constant_shadowers: Hash[String, Array[String]], ?published_constant_names: Set[String], ?local_constant_names: Set[String], ?published_constant_alias_names: Set[String], ?published_constant_ivars: Hash[String, Set[Symbol]], ?data_member_layouts: Hash[String, Array[Symbol]], ?struct_member_layouts: Hash[String, { members: Array[Symbol], keyword_init: bool }], ?param_inferred_types: Hash[[String, Symbol, Symbol], Hash[Symbol, Type::t]], ?discovered_deferred_ranges: Hash[String, Array[[Integer, Integer, Symbol?, Symbol?, String?]]], ?discovered_refinements: Hash[String, Hash[Symbol | String, Array[String]]], ?discovered_global_write_census: Set[Array[untyped]], ?run_generation: Object?, ?patched_line_readers: Set[Symbol], ?clears_last_status: bool, ?defines_case_equality: bool, ?implicit_self_evidence: untyped, ?in_effect_refinements: untyped, ?possible_discovered_methods: Hash[String, Hash[Symbol, Symbol]], ?possible_discovered_deferred_ranges: Hash[String, Array[[Integer, Integer, Symbol?, Symbol?, String?]]], ?contested_discovered_def_nodes: Set[Array[untyped]], ?contested_discovered_singleton_def_nodes: Set[Array[untyped]], ?contested_discovered_method_visibilities: Set[Array[untyped]], ?contested_discovered_parameter_envelopes: Set[Array[untyped]]) -> DiscoveryIndex
+      def with: (?declared_types: Hash[untyped, Type::t], ?class_ivars: Hash[String, Hash[Symbol, Type::t]], ?class_cvars: Hash[String, Hash[Symbol, Type::t]], ?program_globals: Hash[Symbol, Type::t], ?program_global_seeds: Hash[Symbol, Type::t], ?discovered_classes: Hash[String, Type::Singleton], ?in_source_constants: Hash[String, Type::t], ?discovered_methods: Hash[String, Hash[Symbol, Symbol]], ?discovered_def_nodes: Hash[String, Hash[Symbol, untyped]], ?discovered_def_nestings: Hash[untyped, Array[String]], ?discovered_singleton_def_nodes: Hash[String, Hash[Symbol, untyped]], ?discovered_def_sources: Hash[String, Hash[Symbol, String]], ?discovered_singleton_def_sources: Hash[String, Hash[Symbol, String]], ?discovered_method_visibilities: Hash[String, Hash[Symbol | [:singleton, Symbol], Symbol]], ?discovered_parameter_envelopes: Hash[String, Hash[untyped, untyped]], ?discovered_superclasses: Hash[String, String], ?discovered_includes: Hash[String, Array[String]], ?discovered_prepends: Hash[String, Array[String]], ?discovered_extends: Hash[String, Array[String]], ?discovered_class_sources: Hash[String, Set[String]], ?constant_sources: Hash[String, Set[String]], ?constant_writers: Hash[String, Array[String]], ?constant_shadowers: Hash[String, Array[String]], ?published_constant_names: Set[String], ?local_constant_names: Set[String], ?published_constant_alias_names: Set[String], ?published_constant_ivars: Hash[String, Set[Symbol]], ?data_member_layouts: Hash[String, Array[Symbol]], ?struct_member_layouts: Hash[String, { members: Array[Symbol], keyword_init: bool }], ?param_inferred_types: Hash[[String, Symbol, Symbol], Hash[Symbol, Type::t]], ?discovered_deferred_ranges: Hash[String, Array[[Integer, Integer, Symbol?, Symbol?, String?]]], ?discovered_refinements: Hash[String, Hash[Symbol | String, Array[String]]], ?discovered_global_write_census: Set[Array[untyped]], ?run_generation: Object?, ?patched_line_readers: Set[Symbol], ?clears_last_status: bool, ?defines_case_equality: bool, ?implicit_self_evidence: untyped, ?in_effect_refinements: untyped, ?possible_discovered_methods: Hash[String, Hash[Symbol, Symbol]], ?possible_discovered_deferred_ranges: Hash[String, Array[[Integer, Integer, Symbol?, Symbol?, String?]]], ?contested_discovered_def_nodes: Set[Array[untyped]], ?contested_discovered_singleton_def_nodes: Set[Array[untyped]], ?contested_discovered_method_visibilities: Set[Array[untyped]], ?contested_discovered_parameter_envelopes: Set[Array[untyped]]) -> DiscoveryIndex
     end
 
     class IndexedKey
@@ -338,6 +338,7 @@ module Rigor
     # Issue #530 — public so the external-gem ancestry probe asks the same question the walk does.
     def known_user_class?: (String | Symbol name) -> bool
     def singleton_def_for: (String | Symbol class_name, String | Symbol method_name) -> ::Prism::DefNode?
+    def module_function_def?: (untyped, untyped) -> (false | true)
     def singleton_def_through_ancestors: (String | Symbol class_name, String | Symbol method_name, ?name_memo: Hash[untyped, untyped]) -> ([::Prism::DefNode, String] | [nil, nil])
     def user_def_site_for: (String | Symbol class_name, String | Symbol method_name) -> String?
     def user_singleton_def_site_for: (String | Symbol class_name, String | Symbol method_name) -> String?

data/skills/rigor-doctor/references/01-checks.md

@@ -78,17 +78,24 @@ Make sure a single `rigortype` is on the load path.
 - `warn` — the baseline file failed to load. Check the `baseline:` path
   in the config.
 
-### `plugin_gap` — the stack has a plugin that is not enabled
+### `plugin_gap` — the stack has a plugin that is not listed
 
-Read from the `DEPENDENCIES` section of `Gemfile.lock`.
+Read from the `DEPENDENCIES` section of `Gemfile.lock`, plus the Rails
+components a direct `rails` stands for. A `plugins:` entry counts as
+listing its plugin even with `enabled: false`. Skipped when no
+`.rigor.yml` or `.rigor.dist.yml` is discovered in the current directory.
 
 - `fail` — the project depends on gems that bundled plugins model, and
-  **none** of those plugins is enabled: framework calls will not resolve.
-  Add the plugins for the stack to `plugins:` (the `rigor-plugin-tune`
-  skill does this).
+  `plugins:` lists **none** of the bundled plugins that model gems (those
+  declaring `target_gems:`; `rigor-rbs-inline` does not count): framework
+  calls will not resolve. Add the plugins for the stack to `plugins:` (the
+  `rigor-plugin-tune` skill does this). Once any such plugin is listed,
+  the remaining gaps are reported as the per-plugin warnings below.
 - `warn` — one per plugin that models a direct dependency but is not
-  enabled. Enable it, or leave it out deliberately; declining a plugin is
-  a legitimate choice.
+  listed. Add it, or decline it deliberately — declining is a legitimate
+  choice, and the way to record it is a `plugins:` entry with
+  `enabled: false`. Do not enable an unrelated plugin only to silence
+  this check.
 
 ### `gemfile_install` — Rigor is a project dependency
 
@@ -98,10 +105,15 @@ Read from the `DEPENDENCIES` section of `Gemfile.lock`.
 
 ### `bundle_layout` — gem-shipped signatures are not discovered
 
-`warn` when a `Gemfile.lock` exists but Rigor cannot locate the installed
-bundle (the gems live in the active Ruby's default gem home). Gems that
-ship their own `sig/` are then not loaded. Point Rigor at the install
-root with `bundler.bundle_path:`, install into `vendor/bundle`, or supply
+`warn` when a `Gemfile.lock` exists in the current directory but Rigor
+cannot locate the installed bundle — typically the gems live in the
+active Ruby's default gem home. Gems that ship their own `sig/` are then
+not loaded. Rigor looks only where the project records the bundle: a
+`bundler.bundle_path:` in `.rigor.yml` is used alone and must exist;
+without one, and unless `bundler.auto_detect: false`, it reads
+`.bundle/config`'s `BUNDLE_PATH`, then an in-tree `vendor/bundle`, then
+the global Bundler config. Point Rigor at the install root with
+`bundler.bundle_path:`, install into `vendor/bundle`, or supply
 signatures with `rbs collection install` instead.
 
 ## Not covered by `rigor doctor`: is the analysis seeing your code?

data/skills/rigor-type-oracle/references/01-oracle-commands.md

@@ -212,7 +212,8 @@ rigor explain [<rule>]
 | `--format=text\|json` | Default `text`. |
 
 With no argument it lists every rule. With a rule id, a legacy alias, or
-a family prefix (`call`, `flow`, `assert`, `dump`, `def`) it prints the
+a family prefix (`call`, `flow`, `def`, `assert`, `dump`, `global`,
+`suppression`, `static`, `effect`) it prints the
 rule's firing conditions, the severity per profile, the evidence tier,
 and how to suppress it.
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rigortype
 version: !ruby/object:Gem::Version
-  version: 0.4.3
+  version: 0.4.5
 platform: ruby
 authors:
 - Rigor contributors
@@ -321,6 +321,7 @@ files:
 - data/core_overlay/module.rbs
 - data/core_overlay/numeric.rbs
 - data/core_overlay/object_space.rbs
+- data/core_overlay/ostruct.rbs
 - data/core_overlay/pathname.rbs
 - data/core_overlay/proc.rbs
 - data/core_overlay/process.rbs
@@ -445,6 +446,7 @@ files:
 - lib/rigor/analysis/buffer_binding.rb
 - lib/rigor/analysis/check_rules.rb
 - lib/rigor/analysis/check_rules/always_truthy_condition_collector.rb
+- lib/rigor/analysis/check_rules/clause_coverage.rb
 - lib/rigor/analysis/check_rules/dead_assignment_collector.rb
 - lib/rigor/analysis/check_rules/dead_version_guard_arms.rb
 - lib/rigor/analysis/check_rules/declaration_sourced_guard.rb
@@ -454,6 +456,7 @@ files:
 - lib/rigor/analysis/check_rules/lexical_method_sites.rb
 - lib/rigor/analysis/check_rules/main_pass_collector.rb
 - lib/rigor/analysis/check_rules/published_constant_guard.rb
+- lib/rigor/analysis/check_rules/rbs_receiver_surface.rb
 - lib/rigor/analysis/check_rules/return_in_ensure_collector.rb
 - lib/rigor/analysis/check_rules/ruby_deprecations.rb
 - lib/rigor/analysis/check_rules/rule_ids.rb
@@ -704,6 +707,7 @@ files:
 - lib/rigor/inference/builtins/struct_catalog.rb
 - lib/rigor/inference/builtins/time_catalog.rb
 - lib/rigor/inference/captured_locals.rb
+- lib/rigor/inference/clause_widening.rb
 - lib/rigor/inference/closure_escape_analyzer.rb
 - lib/rigor/inference/content_join.rb
 - lib/rigor/inference/coverage_scanner.rb
@@ -742,6 +746,7 @@ files:
 - lib/rigor/inference/in_effect_refinements/walk.rb
 - lib/rigor/inference/index_write_widening.rb
 - lib/rigor/inference/indexed_narrowing.rb
+- lib/rigor/inference/intervening_ivar_reset.rb
 - lib/rigor/inference/jump_targets.rb
 - lib/rigor/inference/key_presence_guard.rb
 - lib/rigor/inference/key_presence_guard/scan.rb
@@ -818,7 +823,10 @@ files:
 - lib/rigor/inference/project_method_ownership.rb
 - lib/rigor/inference/project_patched_definedness_guard.rb
 - lib/rigor/inference/project_patched_methods.rb
+- lib/rigor/inference/project_patched_mixins.rb
 - lib/rigor/inference/project_patched_scanner.rb
+- lib/rigor/inference/project_patched_visibility.rb
+- lib/rigor/inference/project_seed_tables.rb
 - lib/rigor/inference/protection_scanner.rb
 - lib/rigor/inference/range_constant.rb
 - lib/rigor/inference/rbs_type_translator.rb
@@ -828,8 +836,10 @@ files:
 - lib/rigor/inference/refine_self.rb
 - lib/rigor/inference/refined_dispatch.rb
 - lib/rigor/inference/refined_dispatch/class_object.rb
+- lib/rigor/inference/refined_dispatch/constructed_class.rb
 - lib/rigor/inference/refined_dispatch/own_method.rb
 - lib/rigor/inference/refinement_mutation.rb
+- lib/rigor/inference/reflective_ivar_write.rb
 - lib/rigor/inference/repeated_or_writes.rb
 - lib/rigor/inference/return_barrier.rb
 - lib/rigor/inference/rewrite_mutation.rb
@@ -841,6 +851,8 @@ files:
 - lib/rigor/inference/scope_indexer/member_layouts_collector.rb
 - lib/rigor/inference/scope_indexer/mixin_accumulator.rb
 - lib/rigor/inference/scope_indexer/superclasses_collector.rb
+- lib/rigor/inference/self_call_ivar_writes.rb
+- lib/rigor/inference/singleton_external_ahead.rb
 - lib/rigor/inference/singleton_hook_decline.rb
 - lib/rigor/inference/singleton_object_constant.rb
 - lib/rigor/inference/statement_evaluator.rb
@@ -943,6 +955,7 @@ files:
 - lib/rigor/reflection.rb
 - lib/rigor/reflection/constant_ancestors.rb
 - lib/rigor/reflection/constant_path.rb
+- lib/rigor/rooted_glob.rb
 - lib/rigor/runtime/jit.rb
 - lib/rigor/scope.rb
 - lib/rigor/scope/discovery_index.rb
@@ -966,6 +979,7 @@ files:
 - lib/rigor/sig_gen/skip_reason_catalog.rb
 - lib/rigor/sig_gen/superclass_spelling.rb
 - lib/rigor/sig_gen/type_elaborator.rb
+- lib/rigor/sig_gen/write_reporter.rb
 - lib/rigor/sig_gen/write_result.rb
 - lib/rigor/sig_gen/writer.rb
 - lib/rigor/signature_path_audit.rb
@@ -1287,6 +1301,7 @@ files:
 - sig/rigor/plugin/type_node_resolver.rbs
 - sig/rigor/rbs_extended.rbs
 - sig/rigor/reflection.rbs
+- sig/rigor/rooted_glob.rbs
 - sig/rigor/scope.rbs
 - sig/rigor/sig_gen/skip_reason_catalog.rbs
 - sig/rigor/source.rbs