rigortype 0.1.19 → 0.2.1

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

@@ -17,15 +17,12 @@ module Rigor
       # default) when no sigil is present, matching how Sorbet
       # treats sigil-less files.
       #
-      # Slice 5 of ADR-11 uses this purely at catalog-harvest
-      # time: `# typed: ignore` files are skipped entirely (the
-      # plugin records no sigs from them). The other levels are
-      # detected for forward compatibility but treated
-      # identically — per-call-site sigil honouring (e.g. only
-      # firing `T.let` recognition in `# typed: true`+ files)
-      # requires threading the file path through
-      # the per-call recognition path, which lives behind a
-      # future plugin-contract widening slice.
+      # ADR-11 slice 5 uses this at catalog-harvest time:
+      # `# typed: ignore` files are skipped entirely; other
+      # levels gate both sig contributions (`:true`/`:strict`/
+      # `:strong` only) and per-call assertion recognition
+      # (`T.let` / `T.cast` / `T.must` / etc.) via
+      # `Sorbet#assertion_enforced_here?`.
       module SigilDetector
         # Sorbet's strictness-level names. Stored as symbols to
         # match the analyzer's existing convention for level

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

@@ -9,14 +9,6 @@ module Rigor
       # block's `params(...)` and `returns(...)` clauses) into
       # Rigor's internal type carriers.
       #
-      # Slice 1 covered the minimum vocabulary that lets a
-      # typical `sig { params(x: Integer).returns(String) }`
-      # round-trip; slice 3 widens it to cover the dense middle
-      # of Sorbet's surface — generic class applications
-      # (`T::Array[E]`, `T::Hash[K, V]`, etc.), class-object
-      # types (`T.class_of(C)`, `T::Class[T]`), tuples, and
-      # shapes:
-      #
       # | Sorbet form              | Rigor carrier                            |
       # | ------------------------ | ---------------------------------------- |
       # | `Integer` etc.           | `Nominal["Integer"]`                     |
@@ -42,10 +34,9 @@ module Rigor
       #
       # Anything else (`T.proc`, `T.attached_class`,
       # `T.self_type`, `T.type_parameter`, `T::Struct` / `T::Enum`
-      # subclasses, …) degrades to `Dynamic[top]`. The degraded
-      # path stays silent for now per ADR-11's slice plan; a
-      # later slice surfaces the gap as a `dynamic.sorbet.unsupported`
-      # diagnostic.
+      # subclasses, …) degrades silently to `Dynamic[top]`. The
+      # `dynamic.sorbet.unsupported` diagnostic for degraded
+      # forms is deferred.
       module TypeTranslator
         BOOLEAN_NAME = "Boolean"
 
@@ -235,9 +226,8 @@ module Rigor
         # analogue (Singleton names a specific class); the
         # closest faithful translation is `Singleton[name]`
         # when `T` is a constant, or `Singleton[Object]` for
-        # broader applications. Lossy translation; emitted as
-        # `dynamic.sorbet.degraded` once slice 3's diagnostic
-        # surface lands.
+        # broader applications. Lossy — the `dynamic.sorbet.degraded`
+        # diagnostic for this case is deferred.
         def translate_t_class_subscript(args)
           inner = args.first
           return Rigor::Type::Combinator.singleton_of("Class") if inner.nil?

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

@@ -29,11 +29,10 @@ module Rigor
     #   nesting; `def self.foo` is recognised as a singleton
     #   method.
     #
-    # Slice 1 vocabulary is the bare minimum to round-trip the
-    # most common sig shapes; the {TypeTranslator} table
-    # documents what's covered. Anything else (T.proc / T::Array
-    # / T.class_of / T::Struct) degrades silently to
-    # `Dynamic[top]` for now — slice 3 widens the translator.
+    # The {TypeTranslator} table documents coverage. Most of
+    # Sorbet's vocabulary translates; remaining gaps (`T.proc`,
+    # `T::Struct` subclasses, `T.attached_class`, etc.) degrade
+    # silently to `Dynamic[top]`.
     #
     # Architecture: per-run `Catalog` is built lazily on first
     # access by walking every configured `paths:` entry's `.rb`
@@ -99,20 +98,15 @@ module Rigor
         # `false` to record every file's sigs regardless of
         # sigil (current behaviour pre-this-config).
         @enforce_sigil = config.fetch("enforce_sigil")
-        # ADR-11 deferred follow-up — per-call-site assertion
-        # gating. Catalog harvest's `@sigil_by_path` cache is
-        # consulted at every per-call recognition so
-        # `T.let` / `T.cast` / `T.must` / `T.bind` /
-        # `T.assert_type!` only fire in files Sorbet itself
-        # would enforce (`# typed: true` / `:strict` /
-        # `:strong`). When `@enforce_sigil` is off (the user
-        # opted out at harvest time), the gate also opens at
-        # every call site — current behaviour. Files whose
-        # sigil hasn't been observed yet (e.g. the catalog
-        # hasn't run, or the call site is in a fixture /
-        # synthetic path the harvest didn't see) treat
-        # missing-info as enforced — failing-open is friendlier
-        # for spec ergonomics than failing-closed.
+        # Per-call-site assertion gating: `@sigil_by_path` (built
+        # during catalog harvest) is consulted so `T.let` /
+        # `T.cast` / `T.must` / `T.bind` / `T.assert_type!` only
+        # fire in files Sorbet itself would enforce (`:true` /
+        # `:strict` / `:strong`). With `enforce_sigil: false` the
+        # gate is open everywhere. Missing-sigil paths (synthetic
+        # fixtures, out-of-tree call sites) default to enforced —
+        # failing-open suits spec ergonomics better than
+        # failing-closed. See `assertion_enforced_here?`.
         @sigil_by_path = {}
         @catalog = nil
         @parse_errors_by_path = {}
@@ -160,8 +154,7 @@ module Rigor
         diagnostics
       end
 
-      # ADR-52 slice 4 — the per-call return-type path, migrated off
-      # the legacy `flow_contribution_for` hook onto the
+      # ADR-52 slice 4 — per-call return-type path via the
       # method-name-gated `dynamic_return` DSL. The recognised name
       # set is only known at run time (the catalog's `def` names come
       # from the lazy catalog build), so it is declared as a
@@ -170,17 +163,15 @@ module Rigor
       # resolved Symbol Set. The gate is a safe over-approximation —
       # a project method merely *named* `cast` or `find` passes it
       # and is declined by the block's own `T.`-receiver / catalog
-      # checks, exactly as the ungated hook used to decline.
+      # checks.
       dynamic_return methods: -> { recognised_method_names } do |call_node, scope|
         contribution_return_type(call_node, scope)
       end
 
       # ADR-52 slice 4 — `T.bind(self, T)`'s self-narrowing fact,
-      # migrated off the legacy hook's `post_return_facts` slot onto
-      # the method-gated `type_specifier` DSL (once
-      # `flow_contribution_for` is gone, the statement evaluator
-      # consults only this path for narrowing facts). The
-      # return-type half (`Constant[nil]`) flows through the
+      # contributed via the method-gated `type_specifier` DSL. The
+      # statement evaluator consults this path for narrowing facts.
+      # The return-type half (`Constant[nil]`) flows through the
       # `dynamic_return` rule above; the block re-checks the `T.`
       # receiver via the recogniser, so an unrelated `bind` call
       # contributes nothing.
@@ -190,8 +181,8 @@ module Rigor
 
       private
 
-      # ADR-52 slice 4 — the run-time method-name gate for the
-      # `dynamic_return` rule: the static assertion vocabulary
+      # Run-time method-name gate for the `dynamic_return` rule
+      # (ADR-52 slice 4): the static assertion vocabulary
       # (`T.let` / `T.cast` / …), `T.absurd`, and every method name
       # the catalog carries a sig for.
       def recognised_method_names
@@ -202,20 +193,17 @@ module Rigor
         names
       end
 
-      # The migrated body of the legacy `flow_contribution_for` —
-      # same recognition order, but returns the bare `Rigor::Type`
-      # the `dynamic_return` contract expects. Resolves the receiver
-      # in two passes:
+      # Main contribution body for the `dynamic_return` rule.
+      # Returns the bare `Rigor::Type` the contract expects.
+      # Resolves the receiver in three passes:
       #
       # 1. Constant receiver (`User.find(...)`) → singleton-side
       #    catalog lookup.
       # 2. Nominal receiver-type (`user.name` where `user`'s
       #    inferred type is `Nominal["User"]`) → instance-side
       #    catalog lookup.
-      #
-      # Implicit-self calls (no receiver, current-class method)
-      # are deferred to slice 2 — slice 1 covers the common case
-      # where the sig is on the called method's own class.
+      # 3. Implicit-self (receiver-less inside a method body) →
+      #    current-class lookup via `implicit_self_lookup`.
       def contribution_return_type(call_node, scope)
         return nil unless call_node.is_a?(Prism::CallNode)
 
@@ -286,9 +274,8 @@ module Rigor
         contribution&.post_return_facts
       end
 
-      # ADR-11 deferred follow-up — per-call-site assertion
-      # gating. With `enforce_sigil: false`, the gate is fully
-      # open (matches the pre-feature behaviour). With
+      # Per-call-site assertion gating (ADR-11). With
+      # `enforce_sigil: false` the gate is fully open. With
       # `enforce_sigil: true` (default), the caller file's
       # sigil must reach `:true` / `:strict` / `:strong` for
       # assertions to fire. Three honest fallbacks:
@@ -334,7 +321,7 @@ module Rigor
         end
       end
 
-      # ADR-11 slice 2 (deferred from slice 1) — implicit-self calls.
+      # ADR-11 slice 2 — implicit-self calls.
       # A receiver-less call inside a method body resolves against the
       # engine's own `scope.self_type`: `Nominal[Foo]` inside an
       # instance method (instance-side lookup), `Singleton[Foo]` inside

data/sig/rigor/scope.rbs

@@ -11,6 +11,7 @@ module Rigor
     attr_reader indexed_narrowings: Hash[IndexedKey, Type::t]
     attr_reader method_chain_narrowings: Hash[ChainKey, Type::t]
     attr_reader source_path: String?
+    attr_reader struct_fold_safe_locals: Set[Symbol]
 
     # ADR-53 Track A — the seed-time discovery tables live on the
     # DiscoveryIndex; Scope keeps per-table readers as delegates.
@@ -29,6 +30,8 @@ module Rigor
     def discovered_includes: () -> Hash[String, Array[String]]
     def discovered_class_sources: () -> Hash[String, Set[String]]
     def data_member_layouts: () -> Hash[String, Array[Symbol]]
+    def struct_member_layouts: () -> Hash[String, { members: Array[Symbol], keyword_init: bool }]
+    def param_inferred_types: () -> Hash[[String, Symbol, Symbol], Hash[Symbol, Type::t]]
 
     class DiscoveryIndex
       attr_reader declared_types: Hash[untyped, Type::t]
@@ -46,10 +49,12 @@ module Rigor
       attr_reader discovered_includes: Hash[String, Array[String]]
       attr_reader discovered_class_sources: Hash[String, Set[String]]
       attr_reader data_member_layouts: Hash[String, Array[Symbol]]
+      attr_reader struct_member_layouts: Hash[String, { members: Array[Symbol], keyword_init: bool }]
+      attr_reader param_inferred_types: Hash[[String, Symbol, Symbol], Hash[Symbol, Type::t]]
 
       EMPTY: 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], ?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_singleton_def_nodes: Hash[String, Hash[Symbol, untyped]], ?discovered_def_sources: Hash[String, Hash[Symbol, String]], ?discovered_method_visibilities: Hash[String, Hash[Symbol, Symbol]], ?discovered_superclasses: Hash[String, String], ?discovered_includes: Hash[String, Array[String]], ?discovered_class_sources: Hash[String, Set[String]], ?data_member_layouts: Hash[String, Array[Symbol]]) -> 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], ?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_singleton_def_nodes: Hash[String, Hash[Symbol, untyped]], ?discovered_def_sources: Hash[String, Hash[Symbol, String]], ?discovered_method_visibilities: Hash[String, Hash[Symbol, Symbol]], ?discovered_superclasses: Hash[String, String], ?discovered_includes: Hash[String, Array[String]], ?discovered_class_sources: Hash[String, Set[String]], ?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]]) -> DiscoveryIndex
     end
 
     class IndexedKey
@@ -68,6 +73,8 @@ module Rigor
 
     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?) -> void
     def with_source_path: (String? path) -> Scope
+    def with_struct_fold_safe: (Set[Symbol] locals) -> Scope
+    def struct_fold_safe?: (String | Symbol name) -> bool
     def with_discovery: (DiscoveryIndex index) -> Scope
     def local: (String | Symbol name) -> Type::t?
     def ivar: (String | Symbol name) -> Type::t?
@@ -94,6 +101,7 @@ module Rigor
     def discovered_method_visibility: (String | Symbol class_name, String | Symbol method_name) -> Symbol?
     def superclass_of: (String | Symbol class_name) -> String?
     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]
     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

@@ -1,6 +1,6 @@
 module Rigor
   module Type
-    type t = Top | Bot | Dynamic | Constant | IntegerRange | Nominal | Singleton | Union | Difference | Tuple | HashShape | DataClass | DataInstance
+    type t = Top | Bot | Dynamic | Constant | IntegerRange | Nominal | Singleton | Union | Difference | Tuple | HashShape | DataClass | DataInstance | StructClass | StructInstance
 
     type accepts_mode = :strict | :gradual | :loose
 
@@ -277,6 +277,39 @@ module Rigor
       def inspect: () -> String
     end
 
+    class StructClass
+      attr_reader members: Array[Symbol]
+      attr_reader class_name: String?
+      attr_reader keyword_init: bool
+      def initialize: (Array[Symbol] members, ?String? class_name, ?keyword_init: bool) -> void
+      def describe: (?Symbol verbosity) -> String
+      def erase_to_rbs: () -> String
+      def top: () -> Trinary
+      def bot: () -> Trinary
+      def dynamic: () -> Trinary
+      def accepts: (Type::t other, ?mode: accepts_mode) -> AcceptsResult
+      def ==: (untyped other) -> bool
+      def hash: () -> Integer
+      def inspect: () -> String
+    end
+
+    class StructInstance
+      attr_reader members: Hash[Symbol, Type::t]
+      attr_reader class_name: String?
+      def initialize: (Hash[Symbol, Type::t] members, ?String? class_name) -> void
+      def member_names: () -> Array[Symbol]
+      def member_type: (Symbol name) -> Type::t?
+      def describe: (?Symbol verbosity) -> String
+      def erase_to_rbs: () -> String
+      def top: () -> Trinary
+      def bot: () -> Trinary
+      def dynamic: () -> Trinary
+      def accepts: (Type::t other, ?mode: accepts_mode) -> AcceptsResult
+      def ==: (untyped other) -> bool
+      def hash: () -> Integer
+      def inspect: () -> String
+    end
+
     class AcceptsResult
       attr_reader trinary: Trinary
       attr_reader mode: accepts_mode
@@ -339,6 +372,8 @@ module Rigor
       def self?.hash_shape_of: (?Hash[untyped, Type::t]? pairs, **untyped options) -> HashShape
       def self?.data_class_of: (members: Array[Symbol], ?class_name: String?) -> DataClass
       def self?.data_instance_of: (members: Hash[Symbol, Type::t], ?class_name: String?) -> DataInstance
+      def self?.struct_class_of: (members: Array[Symbol], ?class_name: String?, ?keyword_init: bool) -> StructClass
+      def self?.struct_instance_of: (members: Hash[Symbol, Type::t], ?class_name: String?) -> StructInstance
       def self?.union: (*Type::t types) -> Type::t
       def self?.key_of: (Type::t type) -> Type::t
       def self?.value_of: (Type::t type) -> Type::t

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rigortype
 version: !ruby/object:Gem::Version
-  version: 0.1.19
+  version: 0.2.1
 platform: ruby
 authors:
 - Rigor contributors
@@ -281,6 +281,29 @@ files:
 - data/builtins/ruby_core/string.yml
 - data/builtins/ruby_core/struct.yml
 - data/builtins/ruby_core/time.yml
+- data/core_overlay/numeric.rbs
+- data/core_overlay/pathname.rbs
+- data/core_overlay/string_scanner.rbs
+- data/gem_overlay/activesupport/core_ext.rbs
+- data/vendored_gem_sigs/ast/ast.rbs
+- data/vendored_gem_sigs/bcrypt/bcrypt.rbs
+- data/vendored_gem_sigs/bundler/bundler.rbs
+- data/vendored_gem_sigs/cgi/cgi_extras.rbs
+- data/vendored_gem_sigs/did_you_mean/did_you_mean_extras.rbs
+- data/vendored_gem_sigs/idn-ruby/idn.rbs
+- data/vendored_gem_sigs/mysql2/client.rbs
+- data/vendored_gem_sigs/mysql2/error.rbs
+- data/vendored_gem_sigs/mysql2/result.rbs
+- data/vendored_gem_sigs/mysql2/statement.rbs
+- data/vendored_gem_sigs/nokogiri/nokogiri.rbs
+- data/vendored_gem_sigs/nokogiri/nokogiri_html5.rbs
+- data/vendored_gem_sigs/pg/pg.rbs
+- data/vendored_gem_sigs/prism/prism_supplement.rbs
+- data/vendored_gem_sigs/redis/errors.rbs
+- data/vendored_gem_sigs/redis/future.rbs
+- data/vendored_gem_sigs/redis/redis.rbs
+- data/vendored_gem_sigs/redis/redis_extras.rbs
+- data/vendored_gem_sigs/rubygems/rubygems_extras.rbs
 - exe/rigor
 - lib/rigor.rb
 - lib/rigor/analysis/baseline.rb
@@ -322,6 +345,7 @@ files:
 - lib/rigor/bleeding_edge.rb
 - lib/rigor/builtins/hkt_builtins.rb
 - lib/rigor/builtins/imported_refinements.rb
+- lib/rigor/builtins/predefined_constant_refinements.rb
 - lib/rigor/builtins/regex_refinement.rb
 - lib/rigor/builtins/static_return_refinements.rb
 - lib/rigor/cache/descriptor.rb
@@ -342,18 +366,26 @@ files:
 - lib/rigor/cli/ci_detector.rb
 - lib/rigor/cli/command.rb
 - lib/rigor/cli/coverage_command.rb
+- lib/rigor/cli/coverage_mutation.rb
 - lib/rigor/cli/coverage_renderer.rb
 - lib/rigor/cli/coverage_report.rb
+- lib/rigor/cli/coverage_scan.rb
 - lib/rigor/cli/diagnostic_formats.rb
 - lib/rigor/cli/diff_command.rb
 - lib/rigor/cli/explain_command.rb
+- lib/rigor/cli/fused_protection_renderer.rb
+- lib/rigor/cli/fused_protection_report.rb
 - lib/rigor/cli/lsp_command.rb
 - lib/rigor/cli/mcp_command.rb
+- lib/rigor/cli/mutation_protection_renderer.rb
+- lib/rigor/cli/mutation_protection_report.rb
 - lib/rigor/cli/options.rb
 - lib/rigor/cli/plugin_command.rb
 - lib/rigor/cli/plugins_command.rb
 - lib/rigor/cli/plugins_renderer.rb
 - lib/rigor/cli/prism_colorizer.rb
+- lib/rigor/cli/protection_renderer.rb
+- lib/rigor/cli/protection_report.rb
 - lib/rigor/cli/renderable.rb
 - lib/rigor/cli/show_bleedingedge_command.rb
 - lib/rigor/cli/sig_gen_command.rb
@@ -367,12 +399,14 @@ files:
 - lib/rigor/cli/type_scan_command.rb
 - lib/rigor/cli/type_scan_renderer.rb
 - lib/rigor/cli/type_scan_report.rb
+- lib/rigor/config_audit.rb
 - lib/rigor/configuration.rb
 - lib/rigor/configuration/dependencies.rb
 - lib/rigor/configuration/severity_profile.rb
 - lib/rigor/environment.rb
 - lib/rigor/environment/bundle_sig_discovery.rb
 - lib/rigor/environment/class_registry.rb
+- lib/rigor/environment/constant_type_cache_holder.rb
 - lib/rigor/environment/hkt_registry_holder.rb
 - lib/rigor/environment/lockfile_resolver.rb
 - lib/rigor/environment/rbs_collection_discovery.rb
@@ -436,6 +470,7 @@ files:
 - lib/rigor/inference/method_dispatcher/kernel_dispatch.rb
 - lib/rigor/inference/method_dispatcher/literal_string_folding.rb
 - lib/rigor/inference/method_dispatcher/math_folding.rb
+- lib/rigor/inference/method_dispatcher/member_shape_projection.rb
 - lib/rigor/inference/method_dispatcher/method_folding.rb
 - lib/rigor/inference/method_dispatcher/overload_selector.rb
 - lib/rigor/inference/method_dispatcher/rbs_dispatch.rb
@@ -446,18 +481,22 @@ files:
 - lib/rigor/inference/method_dispatcher/shape_dispatch.rb
 - lib/rigor/inference/method_dispatcher/shellwords_folding.rb
 - lib/rigor/inference/method_dispatcher/singleton_folding.rb
+- lib/rigor/inference/method_dispatcher/struct_folding.rb
 - lib/rigor/inference/method_dispatcher/time_folding.rb
 - lib/rigor/inference/method_dispatcher/uri_folding.rb
 - lib/rigor/inference/method_parameter_binder.rb
 - lib/rigor/inference/multi_target_binder.rb
 - lib/rigor/inference/mutation_widening.rb
 - lib/rigor/inference/narrowing.rb
+- lib/rigor/inference/parameter_inference_collector.rb
 - lib/rigor/inference/precision_scanner.rb
 - lib/rigor/inference/project_patched_methods.rb
 - lib/rigor/inference/project_patched_scanner.rb
+- lib/rigor/inference/protection_scanner.rb
 - lib/rigor/inference/rbs_type_translator.rb
 - lib/rigor/inference/scope_indexer.rb
 - lib/rigor/inference/statement_evaluator.rb
+- lib/rigor/inference/struct_fold_safety.rb
 - lib/rigor/inference/synthetic_method.rb
 - lib/rigor/inference/synthetic_method_index.rb
 - lib/rigor/inference/synthetic_method_scanner.rb
@@ -507,6 +546,10 @@ files:
 - lib/rigor/plugin/source_rbs_synthesis_reporter.rb
 - lib/rigor/plugin/trust_policy.rb
 - lib/rigor/plugin/type_node_resolver.rb
+- lib/rigor/protection/diagnostic_oracle.rb
+- lib/rigor/protection/mutation_scanner.rb
+- lib/rigor/protection/mutator.rb
+- lib/rigor/protection/test_suite_oracle.rb
 - lib/rigor/rbs_extended.rb
 - lib/rigor/rbs_extended/conformance_checker.rb
 - lib/rigor/rbs_extended/hkt_directives.rb
@@ -526,7 +569,9 @@ files:
 - lib/rigor/sig_gen/type_elaborator.rb
 - lib/rigor/sig_gen/write_result.rb
 - lib/rigor/sig_gen/writer.rb
+- lib/rigor/signature_path_audit.rb
 - lib/rigor/source.rb
+- lib/rigor/source/constant_path.rb
 - lib/rigor/source/literals.rb
 - lib/rigor/source/node_locator.rb
 - lib/rigor/source/node_walker.rb
@@ -551,8 +596,11 @@ files:
 - lib/rigor/type/integer_range.rb
 - lib/rigor/type/intersection.rb
 - lib/rigor/type/nominal.rb
+- lib/rigor/type/plain_lattice.rb
 - lib/rigor/type/refined.rb
 - lib/rigor/type/singleton.rb
+- lib/rigor/type/struct_class.rb
+- lib/rigor/type/struct_instance.rb
 - lib/rigor/type/top.rb
 - lib/rigor/type/tuple.rb
 - lib/rigor/type/union.rb