rigortype 0.4.4 → 0.4.6

data/sig/rigor/scope.rbs

@@ -14,39 +14,32 @@ module Rigor
     attr_reader void_origins: Hash[untyped, Inference::VoidOrigin]
     attr_reader plugin_typed_calls: Hash[untyped, bool]
     attr_reader optimistic_origins: Hash[untyped, Symbol]
-    # A marked binding whose miss answer is known stores an `Inference::OptimisticOrigin::BoundMark` (a `Data`)
-    # in place of its bare cause (issue #1302).
-    attr_reader optimistic_locals: Hash[Symbol, Symbol | Data]
-    attr_reader optimistic_ivars: Hash[Symbol, Symbol | Data]
-    # sig-gen gap: #1154 — an `attr_reader` over an ivar assigned in `initialize` from a parameter reaches `untyped`.
+    # A marked binding whose miss answer is known stores an `Inference::OptimisticOrigin::BoundMark` in place of
+    # its bare cause (issue #1302).
+    attr_reader optimistic_locals: Hash[Symbol, Symbol | Inference::OptimisticOrigin::BoundMark]
+    attr_reader optimistic_ivars: Hash[Symbol, Symbol | Inference::OptimisticOrigin::BoundMark]
     attr_reader repeated_or_writes: Hash[untyped, bool]
-    # sig-gen gap: #1154 — the same reader shape; `Inference::MatchRebinding::Frame` carries no signature.
+    # sig-gen gap: #2323 — the same reader shape; `Inference::MatchRebinding::Frame` carries no signature.
     attr_reader match_frame: untyped
     attr_reader indexed_narrowings: Hash[IndexedKey, Type::t]
     attr_reader method_chain_narrowings: Hash[ChainKey, Type::t]
     attr_reader source_path: String?
+    # authored: the element is a `Symbol` by contract; a Set's element type stays `untyped` in sig-gen (#2177, #2317), so the generator
+    # would never propose it.
     attr_reader struct_fold_safe_locals: Set[Symbol]
     attr_reader opaque_block_self: bool
-    # sig-gen gap: #1154 — sig-gen skips the reader (sig.skipped.untyped-return): an `attr_reader`
-    # over an ivar assigned in `initialize` from a parameter, so inference reaches `untyped`.
     # Issue #1759 — `:refinement` (REFINEMENT_BLOCK_SELF) directly in a `refine X do … end` block body.
     attr_reader block_self_unknown: bool | :refinement
-    # sig-gen gap: #1154 — sig-gen skips the reader (sig.skipped.untyped-return): an `attr_reader`
-    # over an ivar assigned in `initialize` from a parameter, so inference reaches `untyped`.
     attr_reader singleton_class_body: bool
     attr_reader lexical_nesting: Array[String]?
     # Issue #1429 — a guard's narrowing of a constant reference, keyed by its spelling.
-    # sig-gen gap: #1154 — a reader over an ivar `initialize` assigns from a parameter.
     attr_reader constant_narrowings: Hash[String, Type::t]
     # Issue #1429 — the pre-guard type of each global or constant a guard narrowed.
-    # sig-gen gap: #1154 — a reader over an ivar `initialize` assigns from a parameter.
     attr_reader guard_records: Hash[[Symbol, Symbol | String], Type::t]
     # Issue #1446 — the classes a class guard narrowed a `bot` receiver to.
-    # sig-gen gap: #1154 — a reader over an ivar `initialize` assigns from a parameter.
     attr_reader bot_guard_classes: Hash[[Symbol, Symbol | String], Array[String]]
     # Issue #1667 — the modules a plugin-declared refined block runs under, in declaration order.
-    # sig-gen gap: #1154 — a reader over an ivar `initialize` assigns from a parameter.
-    attr_reader declared_refinements: Array[String]
+    attr_reader declared_refinements: Array[String | Symbol]
 
     # ADR-53 Track A — the seed-time discovery tables live on the
     # DiscoveryIndex; Scope keeps per-table readers as delegates.
@@ -61,28 +54,20 @@ 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]]
-    # sig-gen gap: #1148 — sig-gen skips an endless-def reader (untyped return); the row is hand-written.
+    def discovered_method_visibilities: () -> Hash[String, Hash[Symbol | [:singleton, Symbol], Symbol]]
     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.
     def parameter_envelopes_of: (String class_name) -> Hash[untyped, untyped]
     def discovered_superclasses: () -> Hash[String, String]
-    # sig-gen gap: #1148 — sig-gen skips the endless-def reader (untyped return), so the per-file
-    # deferred-range table's row shape is hand-written.
     def discovered_deferred_ranges: () -> Hash[String, Array[[Integer, Integer, Symbol?, Symbol?, String?]]]
-    # sig-gen gap: #1148 — sig-gen skips the endless-def reader (untyped return), so the refinement table's
-    # shape is hand-written. A method key is a Symbol or the `"*"` wildcard (ADR-121 WD7).
+    # A method key is a Symbol or the `"*"` wildcard (ADR-121 WD7).
     def discovered_refinements: () -> Hash[String, Hash[Symbol | String, Array[String]]]
     # authored: the list holds module names and the `InEffectRefinements::UNKNOWN` Symbol; sig-gen reads the delegated
     # return through an unsigned class as untyped.
     def in_effect_refinements: (untyped node, ?Array[String] declared) -> Array[String | Symbol]
-    # sig-gen gap: #1148 — sig-gen skips the endless-def reader (untyped return), so the census shape is
-    # hand-written.
     def discovered_global_write_census: () -> Set[Array[untyped]]
     def discovered_includes: () -> Hash[String, Array[String]]
     # Issue #1123 — the instance-ancestor-ORDER table beside the include one.
     def discovered_prepends: () -> Hash[String, Array[String]]
-    # sig-gen gap: #1148 — sig-gen skips the endless-def reader (untyped return), so the table shape is hand-written.
     def discovered_extends: () -> Hash[String, Array[String]]
     def discovered_class_sources: () -> Hash[String, Set[String]]
     def constant_sources: () -> Hash[String, Set[String]]
@@ -92,7 +77,8 @@ module Rigor
     def bound_constant_names: (String name) -> Array[String]
     # sig-gen gap: #1150 — the `Data.define` table it reads carries no type, so sig-gen skips the return; the shape is hand-written.
     def shadowing_constant_names: (String name) -> Array[String]
-    # sig-gen gap: #1149 — sig-gen types the `||` fallback `untyped`, so the element type is hand-written.
+    # sig-gen gap: #2309 — the `|| Set.new.freeze` fallback arm types `Set[untyped]` beside the table's `Set[Symbol]`, so the
+    # element type is hand-written.
     def published_constant_ivars_for: (String class_name) -> Set[Symbol]
     def published_constant?: (String name) -> bool
     def record_constant_dependency: (String name) -> void
@@ -110,10 +96,14 @@ module Rigor
     def plugin_typed_call?: (untyped node) -> bool
 
     def with_repeated_or_writes: (untyped nodes) -> Rigor::Scope
-    # sig-gen gap: #1154 — `Hash#key?` over that reader reaches `untyped`, so the `bool` is hand-written.
     def repeated_or_write?: (untyped node) -> bool
 
     class DiscoveryIndex
+      # #1557 — the def-nesting table is a Hash, or an `Inference::ScopeIndexer::LayeredDefNestings` that answers only
+      # `[]` and `empty?`, so that `each` or `key?` over one layer raises instead of reading half the table. A union
+      # rather than an interface: the engine reads an RBS interface as `untyped`, which would check nothing.
+      type def_nestings = Hash[untyped, Array[String]] | Inference::ScopeIndexer::LayeredDefNestings
+
       attr_reader declared_types: Hash[untyped, Type::t]
       attr_reader class_ivars: Hash[String, Hash[Symbol, Type::t]]
       attr_reader class_cvars: Hash[String, Hash[Symbol, Type::t]]
@@ -124,11 +114,11 @@ module Rigor
       attr_reader in_source_constants: Hash[String, Type::t]
       attr_reader discovered_methods: Hash[String, Hash[Symbol, Symbol]]
       attr_reader discovered_def_nodes: Hash[String, Hash[Symbol, untyped]]
-      attr_reader discovered_def_nestings: Hash[untyped, Array[String]]
+      attr_reader discovered_def_nestings: def_nestings
       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 +191,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: def_nestings, ?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
@@ -218,22 +208,19 @@ 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?, ?dynamic_origins: Hash[untyped, Symbol]) -> 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?, ?opaque_block_self: bool, ?block_self_unknown: bool | :refinement, ?singleton_class_body: bool, ?dynamic_origins: Hash[untyped, Symbol], ?indexed_narrowings: Hash[IndexedKey, Type::t], ?method_chain_narrowings: Hash[ChainKey, Type::t], ?declaration_sourced: Set[[Symbol, Symbol] | [Symbol, Symbol, Symbol]], ?published_constant_sourced: Set[[Symbol, Symbol]], ?struct_fold_safe_locals: Set[Symbol], ?lexical_nesting: Array[String]?, ?local_origins: Hash[Symbol, Symbol], ?ivar_origins: Hash[Symbol, Symbol], ?void_origins: Hash[untyped, Inference::VoidOrigin], ?plugin_typed_calls: Hash[untyped, bool], ?optimistic_origins: Hash[untyped, Symbol], ?optimistic_locals: Hash[Symbol, Symbol | Inference::OptimisticOrigin::BoundMark], ?optimistic_ivars: Hash[Symbol, Symbol | Inference::OptimisticOrigin::BoundMark], ?repeated_or_writes: Hash[untyped, bool], ?match_frame: untyped, ?constant_narrowings: Hash[String, Type::t], ?guard_records: Hash[[Symbol, Symbol | String], Type::t], ?bot_guard_classes: Hash[[Symbol, Symbol | String], Array[String]], ?declared_refinements: Array[String | Symbol]) -> void
     def with_source_path: (String? path) -> Scope
     def with_struct_fold_safe: (Set[Symbol] locals) -> Scope
     def with_lexical_nesting: (Array[String]? chain) -> Scope
     def struct_fold_safe?: (String | Symbol name) -> bool
     def entering_opaque_block: () -> Scope
-    # sig-gen gap: #1148 — sig-gen skips the endless-def reader (sig.skipped.untyped-return); the row is hand-written.
     def block_self_unknown?: () -> bool
     REFINEMENT_BLOCK_SELF: :refinement
-    # sig-gen gap: #1148 — sig-gen skips the endless-def predicate (sig.skipped.untyped-return); the row is hand-written.
     def refinement_block_self?: () -> bool
     def with_block_self_unknown: (bool flag) -> Scope
     def opaque_block_self?: () -> bool
     def with_singleton_class_body: (bool) -> Scope
     def with_declared_refinements: (Array[String] names) -> Scope
-    # sig-gen gap: #1148 — sig-gen skips the endless-def reader (sig.skipped.untyped-return); the row is hand-written.
     def singleton_class_body?: () -> bool
     def with_discovery: (DiscoveryIndex index) -> Scope
     def local: (String | Symbol name) -> Type::t?
@@ -261,33 +248,31 @@ module Rigor
     # Issue #1446 — `rigor sig-gen` output.
     def with_guarded_ivar: (untyped name, untyped type, untyped pre_guard) -> Scope
     def without_ivar_guard: (untyped name) -> Scope
-    # sig-gen gap: #1154 — the table reader over an ivar `initialize` assigns from a parameter reaches `untyped`.
     def guard_narrowed_ivar?: (untyped name) -> bool
     # Issue #1446 — `rigor sig-gen` output.
     def with_bot_guard_classes: (untyped kind, untyped name, untyped class_names) -> Scope
-    # sig-gen gap: #1154 — the table reader over an ivar `initialize` assigns from a parameter reaches `untyped`.
     def bot_guard_classes_for: (untyped kind, untyped name) -> Array[String]?
     def without_constant_narrowing: (untyped key) -> Scope
     def guard_narrowed?: () -> bool
     def forget_guard_narrowings: () -> Scope
     def forget_guard_narrowing_of: (untyped kind, untyped name) -> Scope
     def without_constant_narrowings_named: (untyped name) -> Scope
-    # sig-gen gap: #1154 — the table reader over an ivar `initialize` assigns from a parameter reaches `untyped`.
     def constant_narrowing: (String key) -> Type::t?
-    # sig-gen gap: #1151 — an `attr_reader` over a frozen Set literal types `untyped`, as the sibling
-    # `declaration_sourced` row does.
+    # authored: the element is `[Symbol, Symbol]` by contract; a Set's element type stays `untyped` in sig-gen (#2177, #2317), so the generator
+    # would never propose it.
     def published_constant_sourced: () -> Set[[Symbol, Symbol]]
-    # sig-gen gap: #1152 — `Set#include?` over a tuple key types `untyped`, so the `bool` is hand-written.
     def published_constant_sourced?: (Symbol kind, String | Symbol name) -> bool
     def with_published_constant_mark: (Symbol kind, String | Symbol name) -> Scope
     # Issue #1362 — a `[:global_copy, local, global]` record rides beside the `(kind, name)` refs.
+    # authored: the element is a `[Symbol, Symbol]` or `[Symbol, Symbol, Symbol]` tuple by contract; a Set's element type stays `untyped` in sig-gen (#2177, #2317), so the generator
+    # would never propose it.
     def declaration_sourced: () -> Set[[Symbol, Symbol] | [Symbol, Symbol, Symbol]]
     def seed_declaration_sourced_ivar: (String | Symbol name, Type::t type) -> Scope
     def seed_declaration_sourced_global: (String | Symbol name, Type::t type) -> Scope
     def with_global_copy_marks: (String | Symbol name, Array[String | Symbol] globals) -> Scope
     def without_local_declaration_marks: (String | Symbol name) -> Scope
-    # sig-gen gap: #1154 — the records come out of `@declaration_sourced`, an ivar assigned in `initialize` from a
-    # parameter, which reaches `untyped`.
+    # sig-gen gap: #2322 — the records come out of `@declaration_sourced`, whose set now types; `ref[2]` reads as
+    # `Symbol?`, but the `filter_map` over it answers `Array[untyped]`.
     def declaration_sourced_global_copies: (String | Symbol name) -> Array[Symbol]
     def with_declaration_sourced_local: (String | Symbol name, Type::t type) -> Scope
     def with_local_declaration_mark: (String | Symbol name) -> Scope
@@ -300,19 +285,15 @@ module Rigor
     def inferred_param?: (String | Symbol name) -> bool
     def forget_match_globals: () -> Scope
     def untyped_match_globals: () -> Scope
-    # sig-gen gap: #1154 — the reader over the `@globals` ivar `initialize` assigns from a parameter reaches
-    # `untyped`, so the `bool` is hand-written.
     def match_globals_bound?: () -> bool
     def with_match_frame: (untyped body, ?untyped parameters) -> Scope
-    # sig-gen gap: #1154 — the frame reader over an ivar assigned in `initialize` from a parameter reaches
+    # sig-gen gap: #2323 — the frame reader over an ivar assigned in `initialize` from a parameter reaches
     # `untyped`, so the `bool` is hand-written.
     def match_rebinding_closure?: () -> bool
     def forget_last_line: () -> Scope
     def untyped_last_line: () -> Scope
-    # sig-gen gap: #1154 — the reader over the `@globals` ivar `initialize` assigns from a parameter reaches
-    # `untyped`, so the `bool` is hand-written.
     def last_line_bound?: () -> bool
-    # sig-gen gap: #1154 — the frame reader over the `@match_frame` ivar `initialize` assigns from a parameter
+    # sig-gen gap: #2323 — the frame reader over the `@match_frame` ivar `initialize` assigns from a parameter
     # reaches `untyped`, so the `bool` is hand-written.
     def last_line_closure?: () -> bool
     def forget_error_info: () -> Scope
@@ -331,13 +312,14 @@ module Rigor
     def enqueue_ancestors: (String current, Array[String] queue, Hash[untyped, untyped] name_memo, ?mixins: bool) -> void
     def ancestor_name_candidates: (String | Symbol subclass_qualified, String | Symbol raw_ancestor) -> Array[String]
 
-    # sig-gen gap: #1148 — sig-gen skips the method (sig.skipped.untyped-return: every decline returns the
-    # frozen EMPTY_HEADER_NESTING constant); the row is hand-written.
+    # sig-gen gap: #2312 — sig-gen skips the method (sig.skipped.untyped-return): its non-decline arm is the result of
+    # the private helper `ambiguous_ancestor_resolutions_of`, whose parameters are untyped, so the arm is `untyped`.
     def ambiguous_ancestor_resolutions: (String | Symbol subclass_qualified, String | Symbol raw_ancestor) -> Array[String]
 
     # 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?
@@ -355,8 +337,8 @@ module Rigor
     def data_member_layout: (String | Symbol class_name) -> Array[Symbol]?
     def struct_member_layout: (String | Symbol class_name) -> { members: Array[Symbol], keyword_init: bool }?
     def includes_of: (String | Symbol class_name) -> Array[String]
-    # sig-gen gap: #1153 — sig-gen proposes `Array[untyped] | []` off the empty-table early return, so the
-    # element type is hand-written, matching {#includes_of}.
+    # sig-gen gap: #2302 — `names = []` grown by `concat` reads `Array[untyped]`, so the element type is
+    # hand-written, matching {#includes_of}.
     def singleton_extends_of: (String | Symbol class_name) -> Array[String]
     def indexed_narrowing: (Symbol receiver_kind, String | Symbol receiver_name, untyped key) -> Type::t?
     def with_indexed_narrowing: (Symbol receiver_kind, String | Symbol receiver_name, untyped key, Type::t type) -> Scope

data/sig/rigor/type.rbs

@@ -429,14 +429,8 @@ module Rigor
       attr_reader trinary: Trinary
       attr_reader mode: accepts_mode
       attr_reader reasons: Array[String]
-      # sig-gen gap: #1155 — the memoized `||=` return is an honest union with an
-      #   untyped arm (the slot read cannot prove the memoized value), so sig-gen
-      #   skips it (sig.skipped.untyped-return); the runtime result is always
-      #   AcceptsResult and the row is hand-written.
       def self.yes: (?mode: accepts_mode, ?reasons: (Array[String] | String)?) -> AcceptsResult
-      # sig-gen gap: #1155 — same memoized `||=` untyped-return gap as `self.yes`.
       def self.no: (?mode: accepts_mode, ?reasons: (Array[String] | String)?) -> AcceptsResult
-      # sig-gen gap: #1155 — same memoized `||=` untyped-return gap as `self.yes`.
       def self.maybe: (?mode: accepts_mode, ?reasons: (Array[String] | String)?) -> AcceptsResult
       def initialize: (Trinary trinary, ?mode: accepts_mode, ?reasons: (Array[String] | String)?) -> void
       def yes?: () -> bool

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.4
+  version: 0.4.6
 platform: ruby
 authors:
 - Rigor contributors
@@ -446,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
@@ -455,6 +456,9 @@ 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/rebinding_block_callees.rb
+- lib/rigor/analysis/check_rules/rebinding_block_callees/dispatch.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
@@ -475,6 +479,7 @@ files:
 - lib/rigor/analysis/dependency_source_inference/return_type_heuristic.rb
 - lib/rigor/analysis/dependency_source_inference/walker.rb
 - lib/rigor/analysis/diagnostic.rb
+- lib/rigor/analysis/edit_replay.rb
 - lib/rigor/analysis/effects_cache_probe.rb
 - lib/rigor/analysis/erb_template_detector.rb
 - lib/rigor/analysis/fact_store.rb
@@ -491,10 +496,13 @@ files:
 - lib/rigor/analysis/reachability/scan.rb
 - lib/rigor/analysis/reachability/scan_cache.rb
 - lib/rigor/analysis/reachability/signature_scan.rb
+- lib/rigor/analysis/require_relative_closure.rb
 - lib/rigor/analysis/result.rb
 - lib/rigor/analysis/rule_catalog.rb
 - lib/rigor/analysis/run_cache_key.rb
 - lib/rigor/analysis/run_cache_probe.rb
+- lib/rigor/analysis/run_disclosure_credit.rb
+- lib/rigor/analysis/run_disclosure_ledger.rb
 - lib/rigor/analysis/run_stats.rb
 - lib/rigor/analysis/runner.rb
 - lib/rigor/analysis/runner/buffer_pool_dispatcher.rb
@@ -506,6 +514,7 @@ files:
 - lib/rigor/analysis/runner/pool_coordinator.rb
 - lib/rigor/analysis/runner/project_pre_passes.rb
 - lib/rigor/analysis/runner/run_snapshots.rb
+- lib/rigor/analysis/runner/scan_environment.rb
 - lib/rigor/analysis/self_call_resolution_recorder.rb
 - lib/rigor/analysis/severity_stamp.rb
 - lib/rigor/analysis/shadow_harness.rb
@@ -591,6 +600,7 @@ files:
 - lib/rigor/cli/triage_command.rb
 - lib/rigor/cli/triage_renderer.rb
 - lib/rigor/cli/type_of_command.rb
+- lib/rigor/cli/type_of_project_scope.rb
 - lib/rigor/cli/type_of_renderer.rb
 - lib/rigor/cli/type_of_template_probe.rb
 - lib/rigor/cli/type_scan_command.rb
@@ -667,6 +677,7 @@ files:
 - lib/rigor/environment/reflection.rb
 - lib/rigor/environment/reporters.rb
 - lib/rigor/environment/required_features.rb
+- lib/rigor/environment/ruby_library_roots.rb
 - lib/rigor/environment/source_rbs_synthesis.rb
 - lib/rigor/flow_contribution.rb
 - lib/rigor/flow_contribution/conflict.rb
@@ -704,7 +715,9 @@ files:
 - lib/rigor/inference/builtins/string_catalog.rb
 - lib/rigor/inference/builtins/struct_catalog.rb
 - lib/rigor/inference/builtins/time_catalog.rb
+- lib/rigor/inference/callee_mutation_chain.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
@@ -713,6 +726,7 @@ files:
 - lib/rigor/inference/declaration_walk/errors.rb
 - lib/rigor/inference/declaration_walk/shadow.rb
 - lib/rigor/inference/declaration_walk/traversal.rb
+- lib/rigor/inference/deep_erasure.rb
 - lib/rigor/inference/def_handle.rb
 - lib/rigor/inference/def_node_resolver.rb
 - lib/rigor/inference/def_return_typer.rb
@@ -743,6 +757,8 @@ 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/ivar_writer_census.rb
 - lib/rigor/inference/jump_targets.rb
 - lib/rigor/inference/key_presence_guard.rb
 - lib/rigor/inference/key_presence_guard/scan.rb
@@ -750,6 +766,7 @@ files:
 - lib/rigor/inference/last_line/implicit_self.rb
 - lib/rigor/inference/last_line/self_evidence.rb
 - lib/rigor/inference/last_status.rb
+- lib/rigor/inference/loop_value_record.rb
 - lib/rigor/inference/macro_block_self_type.rb
 - lib/rigor/inference/match_rebinding.rb
 - lib/rigor/inference/match_rebinding/calls.rb
@@ -804,6 +821,7 @@ files:
 - lib/rigor/inference/method_dispatcher/uri_folding.rb
 - lib/rigor/inference/method_parameter_binder.rb
 - lib/rigor/inference/module_function_state.rb
+- lib/rigor/inference/module_function_state/spellings.rb
 - lib/rigor/inference/multi_target_binder.rb
 - lib/rigor/inference/mutation_rejoin.rb
 - lib/rigor/inference/mutation_widening.rb
@@ -819,7 +837,11 @@ 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/project_yielder.rb
 - lib/rigor/inference/protection_scanner.rb
 - lib/rigor/inference/range_constant.rb
 - lib/rigor/inference/rbs_type_translator.rb
@@ -829,6 +851,7 @@ 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
@@ -838,12 +861,16 @@ files:
 - lib/rigor/inference/scope_indexer.rb
 - lib/rigor/inference/scope_indexer/certainty.rb
 - lib/rigor/inference/scope_indexer/class_cvars_collector.rb
+- lib/rigor/inference/scope_indexer/declared_ivar_types.rb
+- lib/rigor/inference/scope_indexer/declared_param_writes.rb
 - lib/rigor/inference/scope_indexer/def_nestings_collector.rb
 - lib/rigor/inference/scope_indexer/layered_def_nestings.rb
 - 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/scope_indexer/unseen_ivar_writers.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
@@ -853,6 +880,7 @@ files:
 - lib/rigor/inference/synthetic_method.rb
 - lib/rigor/inference/synthetic_method_index.rb
 - lib/rigor/inference/synthetic_method_scanner.rb
+- lib/rigor/inference/synthetic_method_scanner/project_members.rb
 - lib/rigor/inference/unknown_store_widening.rb
 - lib/rigor/inference/unthreaded_rebinds.rb
 - lib/rigor/inference/untyped_rejoin.rb
@@ -946,6 +974,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
@@ -969,6 +998,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
@@ -1290,6 +1320,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