rigortype 0.1.6 → 0.1.7

data/lib/rigor/inference/expression_typer.rb

@@ -196,8 +196,8 @@ module Rigor
         Prism::UntilNode => :type_of_loop,
         Prism::ForNode => :type_of_dynamic_top,
         Prism::DefinedNode => :type_of_defined,
-        Prism::NumberedReferenceReadNode => :type_of_string_or_nil,
-        Prism::BackReferenceReadNode => :type_of_string_or_nil,
+        Prism::NumberedReferenceReadNode => :type_of_numbered_reference,
+        Prism::BackReferenceReadNode => :type_of_back_reference,
         Prism::MatchPredicateNode => :type_of_match_predicate,
         Prism::MatchRequiredNode => :type_of_match_required,
         Prism::MatchWriteNode => :type_of_dynamic_top,
@@ -347,6 +347,21 @@ module Rigor
         )
       end
 
+      # `$1` / `$2` / ... — numbered match-data globals. When the
+      # narrowing tier has bound a tighter type for this number
+      # (typically `String` after a `=~`-success guard like `unless
+      # /(\d+)/ =~ s; raise; end`), prefer the scope-bound type.
+      # Falls back to the default `String | nil`.
+      def type_of_numbered_reference(node)
+        scope.global(:"$#{node.number}") || type_of_string_or_nil(node)
+      end
+
+      # `$&` / `$'` / `$\`` / `$+` — symbolic back-references. Same
+      # narrowing model as numbered references.
+      def type_of_back_reference(node)
+        scope.global(node.name) || type_of_string_or_nil(node)
+      end
+
       # `expr in pattern` — pattern-match predicate. Returns `true`
       # when the pattern matches, `false` otherwise.
       def type_of_match_predicate(_node)

data/lib/rigor/inference/method_dispatcher/rbs_dispatch.rb

@@ -74,10 +74,21 @@ module Rigor
         #   and binds the method-level type parameter that the
         #   block's return type references to `block_type` (Slice 6
         #   phase C sub-phase 2).
+        # @param self_type_override [Rigor::Type, nil] when set,
+        #   the substitution for `Bases::Self` in the method's
+        #   return type. Used by `MethodDispatcher#try_user_class_fallback`
+        #   to preserve the ORIGINAL receiver as the substitute
+        #   for `self` even though the dispatch is routed through
+        #   `Nominal[Object]` — so that `Bundler::URI::Generic.dup`
+        #   (which resolves through the `Object` fallback because
+        #   `Bundler::URI::Generic` lacks RBS) returns
+        #   `Bundler::URI::Generic` per `Kernel#dup: () -> self`
+        #   rather than `Object`. Defaults to nil (compute self
+        #   from the resolved class_name as before).
         # @return [Rigor::Type, nil] inferred return type, or `nil`
         #   when no rule resolves (no class name, no method, dispatch
         #   on a Top/Dynamic[Top] receiver, etc.).
-        def try_dispatch(receiver:, method_name:, args:, environment:, block_type: nil)
+        def try_dispatch(receiver:, method_name:, args:, environment:, block_type: nil, self_type_override: nil)
           return nil if environment.nil?
           return nil unless environment.rbs_loader
 
@@ -86,7 +97,8 @@ module Rigor
             method_name: method_name,
             args: args,
             environment: environment,
-            block_type: block_type
+            block_type: block_type,
+            self_type_override: self_type_override
           )
         end
 
@@ -128,26 +140,26 @@ module Rigor
         class << self
           private
 
-          def dispatch_for(receiver:, method_name:, args:, environment:, block_type:)
+          def dispatch_for(receiver:, method_name:, args:, environment:, block_type:, self_type_override: nil)
             args ||= []
             case receiver
             when Type::Union
-              dispatch_union(receiver, method_name, args, environment, block_type)
+              dispatch_union(receiver, method_name, args, environment, block_type, self_type_override)
             else
-              dispatch_one(receiver, method_name, args, environment, block_type)
+              dispatch_one(receiver, method_name, args, environment, block_type, self_type_override)
             end
           end
 
-          def dispatch_union(receiver, method_name, args, environment, block_type)
+          def dispatch_union(receiver, method_name, args, environment, block_type, self_type_override = nil)
             results = receiver.members.map do |member|
-              dispatch_one(member, method_name, args, environment, block_type)
+              dispatch_one(member, method_name, args, environment, block_type, self_type_override)
             end
             return nil if results.any?(&:nil?)
 
             Type::Combinator.union(*results)
           end
 
-          def dispatch_one(receiver, method_name, args, environment, block_type)
+          def dispatch_one(receiver, method_name, args, environment, block_type, self_type_override = nil)
             descriptor = receiver_descriptor(receiver)
             return nil unless descriptor
 
@@ -163,7 +175,8 @@ module Rigor
               args: args,
               type_vars: type_vars,
               block_type: block_type,
-              environment: environment
+              environment: environment,
+              self_type_override: self_type_override
             )
           rescue StandardError
             # Defensive: if RBS' definition builder raises on a broken
@@ -254,8 +267,10 @@ module Rigor
             param_names.zip(receiver_args).to_h
           end
 
+          # rubocop:disable Metrics/ParameterLists
           def translate_return_type(method_definition, class_name:, kind:, args:, type_vars:, block_type:,
-                                    environment: nil)
+                                    environment: nil, self_type_override: nil)
+            # rubocop:enable Metrics/ParameterLists
             # Slice 4b-3 (ADR-7 § "Slice 4-A/4-B") — read the
             # return-type override through the merger so future
             # plugin / `:rbs_extended` bundles that also assert a
@@ -266,11 +281,17 @@ module Rigor
             return override if override
 
             instance_type = Type::Combinator.nominal_of(class_name)
-            self_type =
+            resolved_self_type =
               case kind
               when :singleton then Type::Combinator.singleton_of(class_name)
               else                 instance_type
               end
+            # `self_type_override` lets the user-class fallback
+            # path preserve the ORIGINAL receiver as the substitute
+            # for `Bases::Self` — so `Kernel#dup: () -> self`
+            # resolved through the Object fallback returns the
+            # caller's type, not Object.
+            self_type = self_type_override || resolved_self_type
 
             method_type = OverloadSelector.select(
               method_definition,

data/lib/rigor/inference/method_dispatcher.rb

@@ -657,21 +657,38 @@ module Rigor
         fallback_receiver = user_class_fallback_receiver(receiver_type, environment)
         return nil if fallback_receiver.nil?
 
+        # Preserve the ORIGINAL receiver type as the `self`
+        # substitution so `Kernel#dup: () -> self` and other
+        # `self`-returning methods route through Object's RBS
+        # while still returning the caller's type rather than
+        # `Object`. Without this, `base = self.dup` inside a
+        # `Bundler::URI::Generic` instance method types `base`
+        # as `Object` because `Bundler::URI::Generic` is not in
+        # RBS and the fallback's `self` resolves to Object.
         RbsDispatch.try_dispatch(
           receiver: fallback_receiver,
           method_name: method_name,
           args: arg_types,
           environment: environment,
-          block_type: block_type
+          block_type: block_type,
+          self_type_override: receiver_type
         )
       end
 
       def user_class_fallback_receiver(receiver_type, environment)
         case receiver_type
         when Type::Nominal
-          return nil if Rigor::Reflection.rbs_class_known?(receiver_type.class_name, environment: environment)
+          # Modules: even when RBS knows the module, an instance
+          # method on a mixin-only module (e.g. `PP::ObjectMixin`)
+          # observes Kernel / Object methods through every concrete
+          # includer's ancestor chain. Route through the
+          # `Nominal[Object]` fallback so `self.inspect` /
+          # `self.respond_to?` / `self.class` resolve cleanly when
+          # the module itself does not declare them.
+          known = Rigor::Reflection.rbs_class_known?(receiver_type.class_name, environment: environment)
+          return environment.nominal_for_name("Object") if !known || environment.rbs_module?(receiver_type.class_name)
 
-          environment.nominal_for_name("Object")
+          nil
         when Type::Singleton
           return nil if Rigor::Reflection.rbs_class_known?(receiver_type.class_name, environment: environment)
 

data/lib/rigor/inference/narrowing.rb

@@ -950,7 +950,7 @@ module Rigor
         end
 
         def simple_dispatch_name?(name)
-          %i[nil? ! is_a? kind_of? instance_of? == != ===].include?(name)
+          %i[nil? ! is_a? kind_of? instance_of? == != === =~].include?(name)
         end
 
         def dispatch_call_simple(node, scope, name)
@@ -960,9 +960,111 @@ module Rigor
           when :instance_of? then analyse_class_predicate(node, scope, exact: true)
           when :==, :!= then analyse_equality_predicate(node, scope, equality: name)
           when :=== then analyse_case_equality_predicate(node, scope)
+          when :=~ then analyse_regex_match_predicate(node, scope)
           end
         end
 
+        # Survey item (b): `/regex/ =~ str` and `str =~ /regex/`
+        # bind the regex match-data globals on each edge.
+        #
+        # - Truthy edge (`=~` returned an Integer position — the
+        #   match succeeded): `$~` to `Nominal[MatchData]`; `$&`
+        #   and `$1..$N` (where N is the number of capture groups
+        #   in the regex source) to `Nominal[String]`. This is the
+        #   same optimistic-narrowing shape the existing
+        #   `analyse_match_write` uses for named captures inside
+        #   `if /(?<x>...)/ =~ str` — optional groups in the
+        #   regex source (`(\d+)?`) would bind `$N` to `nil` at
+        #   runtime, but the floor here matches the common idiom
+        #   (required captures) and lets `unless /(\d+)/ =~ s;
+        #   raise; end; $1.to_i` resolve cleanly.
+        # - Falsey edge (`=~` returned nil — no match): `$~` and
+        #   every numbered / back-reference global bound to
+        #   `Constant<nil>`.
+        #
+        # Returns nil (no narrowing) when the receiver / argument
+        # pair does not include a `RegularExpressionNode` literal
+        # we can count.
+        def analyse_regex_match_predicate(node, scope)
+          return nil if node.arguments.nil?
+          return nil unless node.arguments.arguments.size == 1
+
+          regex_node = regex_match_literal(node.receiver, node.arguments.arguments.first)
+          return nil if regex_node.nil?
+
+          group_count = count_regex_capture_groups(regex_node.unescaped)
+          regex_match_predicate_scopes(scope, group_count)
+        end
+
+        def regex_match_literal(left, right)
+          return left if left.is_a?(Prism::RegularExpressionNode)
+          return right if right.is_a?(Prism::RegularExpressionNode)
+
+          nil
+        end
+
+        # Curated set of back-reference globals bound by every
+        # `=~`. Numbered references (`$1..$N`) are handled
+        # separately because N depends on the regex source.
+        REGEX_MATCH_GLOBALS = %i[$~ $& $` $' $+].freeze
+        private_constant :REGEX_MATCH_GLOBALS
+
+        def regex_match_predicate_scopes(scope, group_count)
+          string_t = Type::Combinator.nominal_of("String")
+          match_data_t = Type::Combinator.nominal_of("MatchData")
+          nil_t = Type::Combinator.constant_of(nil)
+
+          truthy = scope
+          falsey = scope
+          truthy = truthy.with_global(:$~, match_data_t)
+          falsey = falsey.with_global(:$~, nil_t)
+          REGEX_MATCH_GLOBALS.each do |name|
+            next if name == :$~
+
+            truthy = truthy.with_global(name, string_t)
+            falsey = falsey.with_global(name, nil_t)
+          end
+          group_count.times do |i|
+            name = :"$#{i + 1}"
+            truthy = truthy.with_global(name, string_t)
+            falsey = falsey.with_global(name, nil_t)
+          end
+          [truthy, falsey]
+        end
+
+        # Counts capture groups (numbered + named — both
+        # contribute to `$1..$N`) in a regex source. Backslash
+        # escapes are skipped; non-capturing `(?:...)`, lookahead
+        # `(?=...)` / `(?!...)`, and lookbehind `(?<=...)` /
+        # `(?<!...)` do NOT count. Named groups `(?<name>...)`
+        # DO count. The walker is intentionally light — it does
+        # not parse the regex AST, just scans char-by-char — so
+        # exotic constructs that overlap the lookaround syntax
+        # may miscount; the unsoundness is bounded (over- or
+        # under-binding a few `$N` globals) and we already accept
+        # the same shape of unsoundness for `analyse_match_write`.
+        def count_regex_capture_groups(source)
+          i = 0
+          total = 0
+          length = source.length
+          while i < length
+            c = source[i]
+            if c == "\\"
+              i += 2
+              next
+            end
+            if c == "("
+              if source[i + 1] == "?"
+                total += 1 if source[i + 2] == "<" && source[i + 3] != "=" && source[i + 3] != "!"
+              else
+                total += 1
+              end
+            end
+            i += 1
+          end
+          total
+        end
+
         def dispatch_call_numeric(node, scope, name)
           if COMPARISON_OPERATORS.include?(name)
             analyse_comparison_predicate(node, scope, comparator: name)

data/lib/rigor/inference/scope_indexer.rb

@@ -343,11 +343,26 @@ module Rigor
         unless qualified_prefix.empty?
           body_scope = body_scope.with_self_type(Type::Combinator.singleton_of(qualified_prefix.join("::")))
         end
-        rvalue_type = body_scope.type_of(node.value)
+        rvalue_type = meta_new_constant_type(node, full) || body_scope.type_of(node.value)
         existing = accumulator[full]
         accumulator[full] = existing ? Type::Combinator.union(existing, rvalue_type) : rvalue_type
       end
 
+      # Survey item (e): when the rvalue is a recognised
+      # `Module.new do ... end` / `Class.new do ... end` /
+      # `Struct.new(*sym) do ... end` / `Data.define(*sym) do
+      # ... end` form, type the named constant as
+      # `Singleton[<full>]` so the discovered-method table
+      # registered under `full` becomes reachable through
+      # singleton-side dispatch (`Const.[]=` etc.). Returns nil
+      # for non-meta-new rvalues so the caller falls back to the
+      # default `body_scope.type_of(node.value)` shape.
+      def meta_new_constant_type(node, full)
+        return nil unless meta_new_block_body(node)
+
+        Type::Combinator.singleton_of(full)
+      end
+
       # Slice 7 phase 12 — in-source method discovery pre-pass.
       # Walks every class/module body and records the methods
       # introduced via `Prism::DefNode` (instance + singleton)
@@ -429,16 +444,22 @@ module Rigor
       # v0.1.2 — when a `Const = Data.define(*sym) do ... end`
       # / `Const = Struct.new(*sym) do ... end` constant write
       # carries a block, the block body holds method overrides
-      # whose canonical class is `Const`. Returns the block body
-      # node (a `Prism::StatementsNode`) when the rvalue
-      # matches; nil otherwise. Used by `walk_methods` /
-      # `walk_def_nodes` to push `Const` onto the qualified
-      # prefix before recursing.
+      # whose canonical class is `Const`. Survey item (e) extended
+      # the recognition to `Const = Module.new do ... end` and
+      # `Const = Class.new(?super) do ... end` — the
+      # ADR-16 Tier A "block-as-method" idiom at constant-write
+      # position. Returns the block body node (a
+      # `Prism::StatementsNode`) when the rvalue matches; nil
+      # otherwise. Used by `walk_methods` / `walk_def_nodes` to
+      # push `Const` onto the qualified prefix before recursing.
       def meta_new_block_body(node)
         return nil unless node.is_a?(Prism::ConstantWriteNode)
 
         rvalue = node.value
-        return nil unless data_define_call?(rvalue) || struct_new_call?(rvalue)
+        return nil unless data_define_call?(rvalue) ||
+                          struct_new_call?(rvalue) ||
+                          module_new_call?(rvalue) ||
+                          class_new_call?(rvalue)
 
         rvalue.block&.body
       end
@@ -946,6 +967,31 @@ module Rigor
         positional.all?(Prism::SymbolNode)
       end
 
+      # Recognises `Module.new` and `Module.new(&block)` /
+      # `Module.new do ... end` at constant-write rvalue
+      # position. The block body is the anonymous module's
+      # `module_eval` body; defs inside it bind methods on the
+      # named constant (`Const = Module.new do ...; def foo; ...; end; end`).
+      # Arguments are NOT inspected because `Module.new` accepts
+      # no positionals — Ruby raises ArgumentError if any are
+      # passed — so a malformed call falls through the walker
+      # without affecting analysis.
+      def module_new_call?(node)
+        meta_call_with_name?(node, :Module, :new)
+      end
+
+      # Recognises `Class.new`, `Class.new(super_class)`, and the
+      # block form `Class.new { ... }`. Like `module_new_call?`,
+      # the block body is walked as the anonymous class's body.
+      # The optional `super_class` positional is accepted but does
+      # NOT route through `ancestor` discovery in this slice — the
+      # synthesised class still answers method lookups via its
+      # own body's defs, mirroring how `Struct.new` / `Data.define`
+      # are handled.
+      def class_new_call?(node)
+        meta_call_with_name?(node, :Class, :new)
+      end
+
       def meta_call_with_name?(node, receiver_name, method_name)
         return false unless node.is_a?(Prism::CallNode)
         return false unless node.name == method_name

data/lib/rigor/inference/statement_evaluator.rb

@@ -497,13 +497,25 @@ module Rigor
       def eval_begin(node)
         primary_type, primary_scope = eval_begin_primary(node)
         rescue_chain = collect_rescue_chain_results(node.rescue_clause, scope)
-
-        if rescue_chain.empty?
+        # Rescue arms whose body unconditionally exits (`return`,
+        # `next`, `break`, `raise`, `throw`, `exit`, `abort`,
+        # `fail`) contribute neither a type fragment NOR a scope
+        # to the post-begin flow — control left the `begin` via
+        # that arm. Mirrors the `eval_if` / `eval_unless` /
+        # `eval_and_or` early-return narrowing. Without this
+        # filter, a `rescue ... return` on a local bound only in
+        # the primary body nil-injects that local across the
+        # join, defeating the rescue arm's whole point of guaranteeing
+        # the primary local is in scope for downstream statements.
+        live_rescues = rescue_chain.reject { |_pair, arm_node| branch_unconditionally_exits?(arm_node.statements) }
+                                   .map(&:first)
+
+        if live_rescues.empty?
           exit_type = primary_type
           exit_scope = primary_scope
         else
-          exit_type = Type::Combinator.union(primary_type, *rescue_chain.map(&:first))
-          exit_scope = reduce_scopes_with_nil_injection([primary_scope, *rescue_chain.map(&:last)])
+          exit_type = Type::Combinator.union(primary_type, *live_rescues.map(&:first))
+          exit_scope = reduce_scopes_with_nil_injection([primary_scope, *live_rescues.map(&:last)])
         end
 
         if node.ensure_clause
@@ -540,7 +552,7 @@ module Rigor
         current = rescue_node
         while current
           rescue_scope = bind_rescue_reference(current, entry_scope)
-          results << eval_branch_or_nil(current.statements, rescue_scope)
+          results << [eval_branch_or_nil(current.statements, rescue_scope), current]
           current = current.subsequent
         end
         results
@@ -696,10 +708,35 @@ module Rigor
       # edge-aware: `a && b` can only produce the falsey fragment of
       # `a` when the RHS is skipped, while `a || b` can only produce
       # the truthy fragment of `a` when the RHS is skipped.
+      #
+      # When the RHS unconditionally exits (`raise` / `return` /
+      # `throw` / `exit` / `abort` / `fail` / `next` / `break`), the
+      # post-OR / post-AND scope is the LHS-skipped edge alone:
+      # `a or raise` only survives when `a` was truthy, so subsequent
+      # statements observe `a` narrowed to its truthy fragment; the
+      # symmetric `a and raise` survives only when `a` was falsey.
+      # Same shape as the `eval_if` / `eval_unless` early-return
+      # narrowing.
       def eval_and_or(node)
         left_type, left_scope = sub_eval(node.left, scope)
         truthy_left, falsey_left = Narrowing.predicate_scopes(node.left, left_scope)
         rhs_entry = node.is_a?(Prism::AndNode) ? truthy_left : falsey_left
+        if branch_unconditionally_exits?(node.right)
+          # Walk the RHS for side-effects (on_enter callbacks,
+          # diagnostic dispatch on the raise / return expression
+          # itself) but discard its scope: control never reaches
+          # any statement after `a or raise` via that edge.
+          sub_eval(node.right, rhs_entry)
+          surviving_type =
+            if node.is_a?(Prism::AndNode)
+              Narrowing.narrow_falsey(left_type)
+            else
+              Narrowing.narrow_truthy(left_type)
+            end
+          surviving_scope = node.is_a?(Prism::AndNode) ? falsey_left : truthy_left
+          return [surviving_type, surviving_scope]
+        end
+
         right_type, right_scope = sub_eval(node.right, rhs_entry)
         skipped_type =
           if node.is_a?(Prism::AndNode)
@@ -1106,7 +1143,16 @@ module Rigor
       # narrowing logic via `Narrowing.narrow_for_fact` so the
       # predicate / assert / plugin paths all converge on the
       # same hierarchy-aware narrowing rules.
+      #
+      # v0.1.8 Pillar 2 Slice 1 added the `:local` target_kind
+      # branch so plugins recognising bespoke call shapes
+      # (`expect(x).to be_a(T)`) can directly narrow a named
+      # local in the surrounding scope, bypassing the
+      # parameter-name lookup that requires an authoritative RBS
+      # sig on the called method (which RSpec matchers lack).
       def apply_post_return_fact(fact, call_node, current_scope, method_def)
+        return apply_local_post_return_fact(fact, current_scope) if fact.target_kind == :local
+
         target_node = fact_target_node(fact, call_node, method_def)
         return apply_self_post_return_fact(fact, target_node, current_scope) if fact.target_kind == :self
         return current_scope unless target_node.is_a?(Prism::LocalVariableReadNode)
@@ -1119,6 +1165,21 @@ module Rigor
         current_scope.with_local(local_name, narrowed)
       end
 
+      # v0.1.8 Pillar 2 Slice 1 — narrows the named local directly
+      # without consulting the call node's argument list. The fact's
+      # `target_name` is the local-variable name as written in
+      # source. Silently no-ops when the local is unbound in the
+      # current scope (the plugin's named local may have already
+      # gone out of scope when the contribution fires).
+      def apply_local_post_return_fact(fact, current_scope)
+        local_name = fact.target_name
+        current_type = current_scope.local(local_name)
+        return current_scope if current_type.nil?
+
+        narrowed = Narrowing.narrow_for_fact(current_type, fact, current_scope.environment)
+        current_scope.with_local(local_name, narrowed)
+      end
+
       # v0.1.1 Track 1 slice 3 — `assert self is T` post-return
       # narrowing for the four supported receiver shapes (mirrors
       # `Narrowing#apply_self_fact`).

data/lib/rigor/plugin/macro/heredoc_template.rb

@@ -73,8 +73,8 @@ module Rigor
       # This file ships the value class only. Slice 2b wires the
       # pre-pass that scans Tier C call sites + the
       # `SyntheticMethodIndex` the dispatcher consults; slice 2c
-      # authors `examples/rigor-dry-struct/` and
-      # `examples/rigor-dry-types/` as the worked consumers.
+      # authors `plugins/rigor-dry-struct/` and
+      # `plugins/rigor-dry-types/` as the worked consumers.
       class HeredocTemplate
         NAME_PLACEHOLDER = "\#{name}"
 

data/lib/rigor/plugin/macro/trait_registry.rb

@@ -83,7 +83,7 @@ module Rigor
       # This file ships the value class only. Slice 3b wires the
       # scanner that walks Tier B call sites + the per-method
       # explosion via `SyntheticMethodIndex`; slice 3c authors
-      # `examples/rigor-devise/` model side as the worked consumer.
+      # `plugins/rigor-devise/` model side as the worked consumer.
       class TraitRegistry
         REST_POSITION = :rest
 

data/lib/rigor/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Rigor
-  VERSION = "0.1.6"
+  VERSION = "0.1.7"
 end

data/sig/rigor/environment.rbs

@@ -25,6 +25,7 @@ module Rigor
     def singleton_for_name: (String | Symbol name) -> Type::Singleton?
     def constant_for_name: (String | Symbol name) -> Type::t?
     def class_known?: (String | Symbol name) -> bool
+    def rbs_module?: (String | Symbol name) -> bool
     def class_ordering: (String | Symbol lhs, String | Symbol rhs) -> ordering
     def reflection: () -> untyped?
 
@@ -52,6 +53,7 @@ module Rigor
 
       def initialize: (?libraries: Array[String], ?signature_paths: Array[String | _ToPath], ?cache_store: untyped?) -> void
       def class_known?: (String | Symbol name) -> bool
+      def rbs_module?: (String | Symbol name) -> bool
       def instance_definition: (String | Symbol class_name) -> untyped?
       def instance_method: (class_name: String | Symbol, method_name: String | Symbol) -> untyped?
       def uncached_instance_definition: (String | Symbol class_name) -> untyped?

data/sig/rigor.rbs

@@ -9,6 +9,7 @@ module Rigor
     attr_reader paths: Array[String]
     attr_reader plugins: Array[String]
     attr_reader cache_path: String
+    attr_reader baseline_path: String?
 
     def self.load: (?String path) -> Configuration
     def initialize: (?Hash[String, untyped] data) -> void

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rigortype
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 0.1.7
 platform: ruby
 authors:
 - Rigor contributors
@@ -223,6 +223,7 @@ files:
 - data/builtins/ruby_core/time.yml
 - exe/rigor
 - lib/rigor.rb
+- lib/rigor/analysis/baseline.rb
 - lib/rigor/analysis/buffer_binding.rb
 - lib/rigor/analysis/check_rules.rb
 - lib/rigor/analysis/check_rules/always_truthy_condition_collector.rb
@@ -260,6 +261,7 @@ files:
 - lib/rigor/cache/rbs_known_class_names.rb
 - lib/rigor/cache/store.rb
 - lib/rigor/cli.rb
+- lib/rigor/cli/baseline_command.rb
 - lib/rigor/cli/diff_command.rb
 - lib/rigor/cli/explain_command.rb
 - lib/rigor/cli/lsp_command.rb