rigortype 0.4.5 → 0.4.7

data/sig/rigor/scope.rbs

@@ -14,39 +14,33 @@ 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 construction_facts: Hash[Symbol, Set[untyped]]
     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.
@@ -62,37 +56,40 @@ module Rigor
     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 | [: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.
     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.
+    # authored: the element is an `Array` led by its Symbol kind by contract (`[:defines, name]`, `[:ivar_set, name]`); a Set's element type stays `untyped` in sig-gen (#2177, #2317), so the generator
+    # would never propose it.
     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]]
+    # authored: the element is `String` (a source path) by contract; a Set's element type stays `untyped` in sig-gen (#2177, #2317), so the generator
+    # would never propose it.
     def discovered_class_sources: () -> Hash[String, Set[String]]
+    # authored: the element is `String` (a source path) by contract; a Set's element type stays `untyped` in sig-gen (#2177, #2317), so the generator
+    # would never propose it.
     def constant_sources: () -> Hash[String, Set[String]]
+    # authored: the element is `String` (a constant's last segment) by contract; a Set's element type stays `untyped` in sig-gen (#2177, #2317), so the generator
+    # would never propose it.
     def published_constant_names: () -> Set[String]
+    # authored: the element is `String` (a constant name) by contract; a Set's element type stays `untyped` in sig-gen (#2177, #2317), so the generator
+    # would never propose it.
     def local_constant_names: () -> Set[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 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 +107,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,7 +125,7 @@ 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]]
@@ -201,7 +202,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 | [: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
+      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 +219,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], ?construction_facts: Hash[Symbol, Set[Symbol]], ?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?
@@ -242,10 +240,15 @@ module Rigor
     def global: (String | Symbol name) -> Type::t?
     def local_origin: (String | Symbol name) -> Symbol?
     def ivar_origin: (String | Symbol name) -> Symbol?
+    # sig-gen gap: #2403 — the `Hash#[]` miss in `bound_cause` is lost across the call; sig-gen says `Symbol`.
     def optimistic_local: (String | Symbol name) -> Symbol?
+    # sig-gen gap: #2403 — the `Hash#[]` miss in `bound_cause` is lost across the call; sig-gen says `Symbol`.
     def optimistic_ivar: (String | Symbol name) -> Symbol?
     def optimistic_local_miss: (String | Symbol name) -> Object?
     def optimistic_ivar_miss: (String | Symbol name) -> Object?
+    def construction_fact?: (String | Symbol name, ?Symbol fact) -> bool
+    def project_method_name?: (untyped) -> (false | true)
+    def with_construction_fact: (untyped, untyped) -> Rigor::Scope
     def with_local: (String | Symbol name, Type::t type) -> Scope
     def with_rejoined_locals: (untyped) -> Rigor::Scope
     def with_ivar: (String | Symbol name, Type::t type) -> Scope
@@ -261,33 +264,29 @@ 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`.
     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 +299,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
@@ -326,19 +321,22 @@ module Rigor
     def def_node_slot: (untyped class_name, untyped method_name, ?Symbol kind) -> untyped
     def user_def_for: (String | Symbol class_name, String | Symbol method_name) -> ::Prism::DefNode?
     def user_def_through_ancestors: (String | Symbol class_name, String | Symbol method_name, ?name_memo: Hash[untyped, untyped]) -> ([::Prism::DefNode, String] | [nil, nil])
+    def subclassing_opacity: () -> [false | true, Array[untyped]]
+    def user_instance_def_owners: (untyped) -> Array[untyped]
     def discovered_method_through_ancestors?: (String | Symbol? class_name, String | Symbol method_name, Symbol kind, ?name_memo: Hash[untyped, untyped]) -> bool
     def external_ancestor_name_candidates: (String | Symbol class_name, ?name_memo: Hash[untyped, untyped]) -> Array[Array[String]]
     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 module_function_row_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?
@@ -349,6 +347,9 @@ module Rigor
     # sig-gen gap: #1167 — the instance-side twin: the same untyped `call_node`, the same untyped-return skip.
     def instance_def_shadows_call?: (String | Symbol class_name, String | Symbol method_name, untyped call_node) -> bool
     def top_level_def_for: (String | Symbol method_name) -> ::Prism::DefNode?
+    def ownerless_definition?: (untyped, ?top_level: untyped) -> (false | true)
+    def toplevel_def_ambiguity: (String | Symbol method_name) -> (:contested | :several | :main_singleton | :aliased | :anonymous | :object)?
+    def declared_class?: (String | Symbol class_name) -> bool
     def bindable_top_level_def_for: (String | Symbol method_name) -> ::Prism::DefNode?
     def toplevel?: () -> bool
     def discovered_method_visibility: (String | Symbol class_name, String | Symbol method_name) -> Symbol?
@@ -356,8 +357,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-plugin-author/SKILL.md

@@ -68,10 +68,10 @@ install`), every plugin bundled in the toolchain is readable source.
 Use it as a worked-example library throughout this skill:
 
 ```sh
-rigor plugin list                              # all bundled + example plugins, with paths
-rigor plugin print rigor-activesupport-core-ext  # a plugin's main source, inline
-rigor plugin path  rigor-units                 # the dir, to browse with your file tool
-rigor plugin root                              # gem root + public API (lib/rigor/plugin.rb)
+rigor plugin                                     # all bundled + example plugins, with paths
+rigor plugin rigor-activesupport-core-ext        # a plugin's main source, inline
+rigor plugin --path rigor-units                  # the dir, to browse with your file tool
+rigor plugin --root                              # gem root + public API (lib/rigor/plugin.rb)
 ```
 
 `rigor plugin` (singular) browses the toolchain's plugins; `rigor

data/skills/rigor-plugin-author/references/02-walker-and-types.md

@@ -254,8 +254,8 @@ Two ways to wire the RBS, depending on how the plugin is packaged:
    read one as a worked example:
 
    ```sh
-   rigor plugin print rigor-activesupport-core-ext   # see manifest + sig/ layout
-   rigor plugin path  rigor-activesupport-core-ext   # then browse its sig/ dir
+   rigor plugin rigor-activesupport-core-ext         # see manifest + sig/ layout
+   rigor plugin --path rigor-activesupport-core-ext  # then browse its sig/ dir
    ```
 
 2. **A project-private plugin** — the manifest field still works, but
@@ -280,9 +280,9 @@ They compose — many plugins ship both.
 
 > **Browse a real plugin instead of guessing the API.** Because Rigor
 > is installed on disk (`mise` / `gem install`), every bundled plugin's
-> source is readable as a worked example. `rigor plugin list` shows
-> them all with absolute paths; `rigor plugin print <name>` inlines a
-> plugin's main source; `rigor plugin root` points at the engine source
+> source is readable as a worked example. `rigor plugin` shows
+> them all with absolute paths; `rigor plugin <name>` inlines a
+> plugin's main source; `rigor plugin --root` points at the engine source
 > and the public `Rigor::Plugin::Base` API. When the prose here is
 > thinner than you need, read a shipped plugin that does the same thing.
 

data/skills/rigor-plugin-review/SKILL.md

@@ -74,9 +74,9 @@ Rigor is installed on disk, so both the plugin under review and the
 worked-example plugins are readable source:
 
 ```sh
-rigor plugin list                 # every bundled + example plugin, with paths
-rigor plugin print rigor-<id>     # a plugin's main source, inline
-rigor plugin path  rigor-<id>     # its directory, to browse
+rigor plugin                    # every bundled + example plugin, with paths
+rigor plugin rigor-<id>         # a plugin's main source, inline
+rigor plugin --path rigor-<id>  # its directory, to browse
 ```
 
 The **authoritative** authoring surface — the one this review scores

data/skills/rigor-project-init/references/03-baseline-and-bugs.md

@@ -218,8 +218,19 @@ baseline is a ceiling, not a blanket. Reducing it later is the
 Recommend committing `.rigor-baseline.yml` — it documents project
 state; list it in the Final step's file inventory.
 
+**Rule-less diagnostics cannot be baselined.** A file Prism cannot
+parse (a parse error), a missing `paths:` entry or an internal error
+yields a diagnostic with no rule, so it has no `(file, rule)` bucket.
+The summary then prints a second line ("N diagnostic(s) have no rule
+(parse, path or internal errors) in M file(s) and cannot be
+baselined") and lists the files; the command still exits 0. Acknowledge
+mode reaches a green `rigor check` only after those files are fixed or
+added to `exclude:`, or the bad `paths:` entry is removed. Do that
+before wiring `baseline:`, then re-run `rigor baseline regenerate`.
+
 Print the suppression summary for the user: "N diagnostics recorded
-as baseline; M will surface on subsequent runs."
+as baseline; M will surface on subsequent runs." Take N from the
+`covering N diagnostic(s)` count, and count the unbaselineable ones in M.
 
 ## Phase 8 — Surface real bugs & offer escalation