rigortype 0.1.19 → 0.2.0

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

@@ -11,15 +11,13 @@ require_relative "rspec/let_type_resolver"
 module Rigor
   module Plugin
     # rigor-rspec — validates RSpec `let` / `subject`
-    # declarations within each describe / context scope.
+    # declarations within each describe / context scope,
+    # narrows `expect(x).to MATCHER` assertions downstream,
+    # and binds `let`/`subject` locals to their inferred
+    # return types inside `it` bodies.
     #
     # Tier 3A of the [Rails plugins roadmap](../../../../docs/design/20260508-rails-plugins-roadmap.md).
-    # Deliberately scoped — the roadmap describes a much
-    # larger plugin (let-typo detection in `it` bodies,
-    # `expect(x).to receive(:method)` mock-target
-    # validation). Both are out of scope for v0.1.0; this
-    # plugin ships the two checks that have the lowest
-    # false-positive risk:
+    # Ships four checks:
     #
     # 1. **Duplicate `let` / `subject` declarations** in
     #    the same scope (`warning`). RSpec's runtime lets
@@ -31,14 +29,21 @@ module Rigor
     #    (`error`). At runtime this infinite-loops; users
     #    typically meant to call a different method or
     #    forgot to introduce a `super`.
+    # 3. **`expect(x).to MATCHER` narrowing** — narrows
+    #    the named local `x` on the post-call edge for
+    #    eight matchers (see `MatcherAnalyzer`).
+    # 4. **`let`/`subject` local binding** — binds `let`
+    #    / `subject` names in `it` bodies to the block's
+    #    inferred return type (see `LetTypeResolver`).
     #
     # ## Configuration
     #
-    # No knobs in v0.1.0. The plugin walks every analysed
-    # file looking for `RSpec.describe ... do` blocks; spec
-    # files outside the project's `paths:` are not scanned.
+    # No configuration knobs. The plugin walks every
+    # analysed file for `RSpec.describe ... do` blocks;
+    # spec files outside the project's `paths:` are not
+    # scanned.
     #
-    # ## Limitations (v0.1.0)
+    # ## Limitations
     #
     # - **No let-typo detection.** Detecting an `it`
     #   block's reference to a misspelled `let` name
@@ -102,14 +107,14 @@ module Rigor
         Analyzer.diagnose(path: path, root: root).map { |diag| build_diagnostic(diag) }
       end
 
-      # ADR-37 slice 2 — Pillar 2 Slice 1 matcher narrowing
+      # ADR-37 slice 2 — matcher narrowing
       # (`expect(x).to be_a(T)` → `post_return_facts` on `x`),
       # method-gated by the engine on the expectation verbs.
       type_specifier methods: %i[to not_to to_not] do |call_node, scope|
         MatcherAnalyzer.contribution_for(call_node, environment: scope&.environment)&.post_return_facts
       end
 
-      # Pillar 2 Slice 2 / ADR-52 slice 5a — binds local reads in `it` /
+      # ADR-52 slice 5a — binds local reads in `it` /
       # spec bodies to their `let(:name) { ... }` block's inferred return
       # type. The name set varies per file (each spec file's
       # `describe`/`let` structure), so the rule gates on the per-file
@@ -130,7 +135,7 @@ module Rigor
         let_scope_index_for(path)&.let_names || []
       end
 
-      # Pillar 2 Slice 2 — when the call node is a no-receiver
+      # When the call node is a no-receiver
       # method call (`user`, `subject`, etc.) inside an RSpec
       # `describe` block whose lets include a matching name,
       # return the let block's inferred type.

data/plugins/rigor-shoulda-matchers/lib/rigor/plugin/shoulda_matchers/analyzer.rb

@@ -31,7 +31,6 @@ module Rigor
       #   validate_absence_of(:col)
       #   validate_format_of(:col)
       #   validate_confirmation_of(:col)
-      #   allow_value(...).for(:col)
       #   have_db_column(:col)
       #   have_db_index(:col)
       #

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

@@ -9,10 +9,11 @@ module Rigor
       # analyzer can validate `Worker.perform_async(...)`
       # call sites.
       #
-      # Same envelope shape as `rigor-activejob`'s
-      # `JobIndex::Entry`: `min_arity` / `max_arity` form a
-      # closed range (`Float::INFINITY` for the upper bound
-      # when `*args` is present).
+      # Uses the same `min_arity` / `max_arity` closed-range
+      # envelope as `rigor-activejob`'s `JobIndex::Entry`
+      # (`Float::INFINITY` upper bound when `*args` is present);
+      # Sidekiq workers serialize args to JSON so keyword arity
+      # is not tracked here.
       class WorkerIndex
         Entry = Data.define(:class_name, :min_arity, :max_arity) do
           def arity_label

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

@@ -168,9 +168,8 @@ module Rigor
         # contribution mirrors `T.must` minus the nil-stripping:
         # the call's return type is the inner expression's
         # inferred type. The companion diagnostic is emitted by
-        # the plugin's `diagnostics_for_file` hook through
-        # {RevealTypeRecognizer}; the recogniser here is
-        # contribution-only.
+        # the plugin's `diagnostics_for_file` hook; this
+        # method handles the contribution only.
         def resolve_reveal_type(call_node, scope)
           inner = nth_argument(call_node, 0)
           return Rigor::Type::Combinator.untyped if inner.nil? || scope.nil?

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

@@ -4,22 +4,18 @@ module Rigor
   module Plugin
     class Sorbet < Rigor::Plugin::Base
       # Frozen description of one Sorbet `sig` block as parsed by
-      # {SigParser}. Holds enough to reconstruct the method's
-      # call-site return type (slice 1's deliverable) plus the
-      # parameter shape and modifier list (kept for slice 2+ when
-      # we begin checking call-site argument types and override
-      # compatibility).
+      # {SigParser}. Holds the return type, parameter shape, and
+      # modifier list. Call-site argument-type checking and
+      # override-compatibility validation are deferred; only the
+      # return-type contribution is active.
       #
       # `kind` distinguishes `def foo` (`:instance`) from
       # `def self.foo` / `class << self; def foo; end`
       # (`:singleton`).
       #
-      # `modifiers` is the set of `sig`-level modifiers we
-      # observed: `:abstract`, `:override`, `:overridable`,
-      # `:final`. Slice 1 records them but does not act on them;
-      # later slices wire `:abstract` into the existing
-      # `def.return-type-mismatch` check and `:override` into
-      # override-compatibility validation.
+      # `modifiers` records the `sig`-level flags observed:
+      # `:abstract`, `:override`, `:overridable`, `:final`.
+      # Currently stored but not acted on.
       MethodSignature = Data.define(
         :class_name, :method_name, :kind, :params, :return_type, :modifiers
       )

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

@@ -26,9 +26,8 @@ module Rigor
       # whatever it recognises (`params` / `returns` / `void` /
       # `abstract` / `override` / `overridable` / `final` /
       # `type_parameters` / `checked` / `on_failure`) into a
-      # frozen result hash. Slice 1 wires the parsed structure
-      # into {MethodSignature}; later slices will start *acting*
-      # on the modifiers and `type_parameters`.
+      # frozen result hash stored in {MethodSignature}. Modifiers
+      # and `type_parameters` are recorded but not yet acted on.
       #
       # The parser is intentionally tolerant — unknown chain
       # nodes degrade to "the rest of the chain is opaque" rather
@@ -93,8 +92,8 @@ module Rigor
             when :params
               accumulator[:params].merge!(parse_params(current))
             when :type_parameters
-              # Slice 1: recognise to suppress the degraded
-              # path; widen translation in slice 3.
+              # Recognised to suppress the degraded path;
+              # payload intentionally discarded (deferred).
             when *RECOGNISED_MODIFIERS
               accumulator[:modifiers] << current.name
             when *RUNTIME_ONLY_STEPS

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.0
 platform: ruby
 authors:
 - Rigor contributors
@@ -322,6 +322,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
@@ -344,16 +345,21 @@ files:
 - lib/rigor/cli/coverage_command.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/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
@@ -373,6 +379,7 @@ files:
 - 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 +443,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 +454,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 +519,8 @@ 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/mutation_scanner.rb
+- lib/rigor/protection/mutator.rb
 - lib/rigor/rbs_extended.rb
 - lib/rigor/rbs_extended/conformance_checker.rb
 - lib/rigor/rbs_extended/hkt_directives.rb
@@ -527,6 +541,7 @@ files:
 - lib/rigor/sig_gen/write_result.rb
 - lib/rigor/sig_gen/writer.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 +566,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