rigortype 0.4.5 → 0.4.6

data/lib/rigor/type/combinator.rb

@@ -1040,9 +1040,10 @@ module Rigor
         # No type carrier has a method that changes it once built (a built type is frozen; one `Marshal.load`
         # restores is not, but nothing mutates it either), so a memoised key cannot go stale. The memo is weak
         # in both key and value: it keeps neither the type nor the string alive, and an entry whose string
-        # nothing else holds is dropped at the next GC. It is keyed by identity on purpose: `Constant[0.0]` and
-        # `Constant[-0.0]` are equal and hash alike, but render differently. A non-main Ractor may not read the
-        # module's ivar, so a pool worker renders the key every time, as every run did before.
+        # nothing else holds is dropped at the next GC. It is keyed by identity on purpose: two equal members
+        # need not render alike (`Constant[1..2]` and `Constant[1..2.0]`), so equality is not a safe key. A
+        # non-main Ractor may not read the module's ivar, so a pool worker renders the key every time, as every
+        # run did before.
         def sort_key(member)
           return member.describe(:short) unless Ractor.main?
 

data/lib/rigor/type/constant.rb

@@ -79,7 +79,10 @@ module Rigor
       # Scalar carriers without RBS Literal support (Float, Range, Rational, Complex, Regexp, Pathname)
       # keep their pre-existing widen-to-class-name behaviour because RBS rejects their literal spellings
       # as syntax errors. `Range` is generic (`Range[out E]`), and a bare `Range` fails `rbs validate`, so
-      # it carries the class of its endpoints, or `untyped` when both are nil (#1891).
+      # it carries the class of its endpoints, or `untyped` when both are nil (#1891). `Set[unchecked out A]` is
+      # generic too, and a set is mutable: the constant's elements are only what it held when it was built, and
+      # `x << "a"` adds a member they do not name. It erases to `Set[untyped]`, as an Array or Hash literal's
+      # element type is widened rather than pinned (#2177).
       def erase_to_rbs
         case value
         when true then "true"
@@ -88,6 +91,7 @@ module Rigor
         when Integer then value.to_s
         when Symbol, String then value.inspect
         when Range then "Range[#{range_element_rbs}]"
+        when ::Set then "Set[untyped]"
         else value.class.name
         end
       end
@@ -96,13 +100,51 @@ module Rigor
 
       include Rigor::Type::AcceptanceRouter
 
+      # Two carriers are equal when they pin the same value, which for a Float is stricter than Ruby's `==`
+      # (#1513): `0.0` and `-0.0` are distinct values (`1.0 / x` tells them apart), so `0.0 | -0.0` keeps both
+      # members, and a NaN equals another NaN, so `==` stays reflexive and a union never collects one NaN member
+      # per occurrence. A Complex compares its parts the same way.
       def ==(other)
-        other.is_a?(Constant) && value.class == other.value.class && value == other.value
+        other.is_a?(Constant) && value.class == other.value.class && Constant.same_value?(value, other.value)
       end
       alias eql? ==
 
       def hash
-        [Constant, value.class, value].hash
+        [Constant, value.class, Constant.value_key(value)].hash
+      end
+
+      # True when `left` and `right` (of one class) are the same value in the sense of {#==}.
+      def self.same_value?(left, right)
+        case left
+        when Float then same_float?(left, right)
+        when Complex then same_float?(left.real, right.real) && same_float?(left.imaginary, right.imaginary)
+        else left == right
+        end
+      end
+
+      def self.same_float?(left, right)
+        return left == right unless left.is_a?(Float) && right.is_a?(Float)
+        return right.nan? if left.nan?
+
+        left.eql?(right) && (!left.zero? || (1.0 / left).positive? == (1.0 / right).positive?)
+      end
+
+      # A key whose `eql?` / `hash` agree with {.same_value?}: `uniq { |v| Constant.value_key(v) }` keeps
+      # `0.0` and `-0.0` apart and folds every NaN into one. Any other value is its own key, so plain `uniq`
+      # semantics are unchanged for it.
+      def self.value_key(value)
+        case value
+        when Float then float_key(value)
+        when Complex then [Complex, float_key(value.real), float_key(value.imaginary)]
+        else value
+        end
+      end
+
+      def self.float_key(value)
+        return value unless value.is_a?(Float)
+        return :nan if value.nan?
+
+        value.zero? ? [Float, (1.0 / value)] : value
       end
 
       def inspect

data/lib/rigor/type/hash_shape.rb

@@ -29,7 +29,7 @@ module Rigor
       EXTRA_KEY_POLICIES = %i[open closed].freeze
       POLICY_KEYWORDS = %i[required_keys optional_keys read_only_keys extra_keys].freeze
       # A Symbol whose text matches renders as a bare RBS record key (`lang:`) in {#erase_to_rbs};
-      # anything else must be quoted with a fat arrow (`"data-contrast" =>`). See {#erase_key_prefix}.
+      # anything else is a quoted Symbol with a fat arrow (`:"data-contrast" =>`). See {#erase_key_prefix}.
       BARE_RECORD_KEY = /\A[A-Za-z_][A-Za-z0-9_]*[?!]?\z/
 
       attr_reader :pairs, :required_keys, :optional_keys, :read_only_keys, :extra_keys
@@ -72,7 +72,7 @@ module Rigor
       def erase_to_rbs
         return "{}" if pairs.empty? && closed?
         return hash_erasure unless closed?
-        return hash_erasure if pairs.each_key.any? { |k| !k.is_a?(Symbol) }
+        return hash_erasure if pairs.each_key.any? { |k| !k.is_a?(Symbol) || !record_key_spellable?(k) }
 
         rendered = pairs.map { |k, v| "#{erase_key_prefix(k)} #{v.erase_to_rbs}" }
         "{ #{rendered.join(', ')} }"
@@ -221,21 +221,26 @@ module Rigor
 
       # An RBS record entry's key + separator, for the {#erase_to_rbs} path (which only ever sees
       # Symbol keys — string-keyed shapes degrade to `Hash[...]` before reaching here). A Symbol whose
-      # text is a plain identifier is a bare key with a colon (`lang:`); a hyphenated / punctuated
-      # Symbol MUST use the quoted `"data-contrast" =>` form, because RBS rejects both a bare
-      # non-identifier (`data-contrast:`) and a quoted key with a colon (`"data-contrast":`). Getting
-      # this wrong made sig-gen emit an unparseable Mastodon `html_attributes` shape that crashed the
-      # whole RBS env build. Valid identifier keys (incl. Ruby keywords like `class`) keep the colon
-      # form, so only genuinely non-identifier keys change. Optional keys carry a leading `?`.
+      # text is a plain identifier is a bare key with a colon (`lang:`, Ruby keywords like `class`
+      # included). Any other Symbol is a quoted Symbol literal with a fat arrow (`:"data-contrast" =>`):
+      # RBS rejects a bare non-identifier (`data-contrast:`) and a quoted key with a colon
+      # (`"data-contrast":`), and reads `"data-contrast" =>` as the String key, so the written record
+      # declared a key the body never has (#2176). Optional keys carry a leading `?`.
       def erase_key_prefix(key)
         optional = optional_key?(key) ? "?" : ""
         if BARE_RECORD_KEY.match?(key.to_s)
           "#{optional}#{key}:"
         else
-          "#{optional}#{key.to_s.inspect} =>"
+          "#{optional}:#{key.to_s.inspect} =>"
         end
       end
 
+      # `String#inspect` escapes `#{`, `#$` and `#@` as `\#`, which RBS's parser does not read back as
+      # `#`. A key spelled that way would name a different Symbol, so the shape erases to `Hash[...]`.
+      def record_key_spellable?(key)
+        !key.to_s.inspect.include?("\\#")
+      end
+
       def hash_erasure
         return "Hash[top, top]" if open?
         return "Hash" if pairs.empty?

data/lib/rigor/type/struct_instance.rb

@@ -63,10 +63,11 @@ module Rigor
       end
 
       # Erases to the tagging class nominal (conservative: the structural members are not RBS-expressible
-      # as a class instance). The anonymous case erases to the `Struct` supertype.
+      # as a class instance). The anonymous case erases to the `Struct` supertype with an `untyped`
+      # element: `Struct[Elem]` is generic, and a bare `Struct` fails `rbs validate` (#2177).
       def erase_to_rbs
         name = class_name
-        return "Struct" if name.nil?
+        return "Struct[untyped]" if name.nil?
 
         name
       end

data/lib/rigor/version.rb

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

data/plugins/rigor-actionmailer/lib/rigor/plugin/actionmailer/mailer_discoverer.rb

@@ -216,9 +216,10 @@ module Rigor
         # - `initialize`
         # - methods starting with `_` (Ruby convention for private/internal)
         # - `def self.<name>` (singleton-side)
-        # - methods after a bare `private` (or `public` → `private` transition) — these are internal
-        #   helpers, not actions
-        # - methods named as a `private :foo` argument
+        # - methods that are not public at the end of the class body, read in source order: after a bare
+        #   `private` / `protected` (until a `public` switches back), named by `private :foo` /
+        #   `protected :foo`, or defined inline (`private def foo`) — Rails builds `action_methods` from the
+        #   public instance methods. `public :foo` after a `protected` section makes `foo` an action again.
         # - methods named as a callback target (`before_action :name`, `after_action`, `around_action`)
         #
         # Pre-fix, Mastodon's `AdminMailer#process_params` / `set_instance` / `set_locale` /
@@ -227,64 +228,80 @@ module Rigor
         CALLBACK_DECLARATIONS = %i[before_action after_action around_action].freeze
         private_constant :CALLBACK_DECLARATIONS
 
+        VISIBILITY_KEYWORDS = %i[public private protected].freeze
+        private_constant :VISIBILITY_KEYWORDS
+
         def collect_action_defs(body)
           return [] if body.nil?
 
-          private_names, callback_names = collect_visibility_and_callbacks(body)
-          visibility = :public
+          callback_names = collect_callback_names(body)
+          def_nodes, final_visibility = scan_visibility(body)
 
-          body.compact_child_nodes.flat_map do |node|
-            visibility = next_visibility(node, visibility)
-            next [] unless node.is_a?(Prism::DefNode)
-            next [] if node.receiver.is_a?(Prism::SelfNode)
-            next [] if node.name == :initialize
-            next [] if node.name.to_s.start_with?("_")
-            next [] if visibility == :private
-            next [] if private_names.include?(node.name)
-            next [] if callback_names.include?(node.name)
+          def_nodes.select do |node|
+            next false if node.receiver.is_a?(Prism::SelfNode)
+            next false if node.name == :initialize
+            next false if node.name.to_s.start_with?("_")
+            next false if callback_names.include?(node.name)
 
-            [node]
+            # Rails builds `action_methods` from the PUBLIC instance methods, so only a method whose final
+            # visibility is public is an action.
+            final_visibility[node.name] == :public
           end
         end
 
-        # First pass over the class body: collect (a) names passed to `private :foo` / `protected :foo`
-        # (explicit visibility-on-existing-method form), and (b) Symbol arguments to callback
-        # declarations (`before_action :setup`, etc.).
-        def collect_visibility_and_callbacks(body)
-          private_names = []
-          callback_names = []
-
+        # Symbol arguments to callback declarations (`before_action :setup`, etc.).
+        def collect_callback_names(body)
+          names = []
           body.rigor_each_child do |node|
-            next unless node.is_a?(Prism::CallNode) && node.receiver.nil?
+            next unless node.is_a?(Prism::CallNode) && node.receiver.nil? && CALLBACK_DECLARATIONS.include?(node.name)
 
-            args = (node.arguments&.arguments || []).filter_map do |arg|
-              Rigor::Source::Literals.symbol(arg)
+            (node.arguments&.arguments || []).each do |arg|
+              symbol = Rigor::Source::Literals.symbol(arg)
+              names << symbol if symbol
             end
-            next if args.empty?
+          end
+          names.to_set
+        end
 
-            case node.name
-            when :private, :protected then private_names.concat(args)
-            when *CALLBACK_DECLARATIONS then callback_names.concat(args)
+        # Walks the class body in source order and returns `[def_nodes, final_visibility]`: every `def` the body
+        # spells (a direct statement or the inline argument of a visibility call, `private def x`), and the
+        # visibility each method name ends with. A bare `public` / `private` / `protected` sets the default for
+        # the defs after it; `private :x` / `public :x` / `protected def x` set that one method, whichever side of
+        # its `def` they fall on in the source, and the last statement to name a method wins.
+        def scan_visibility(body)
+          def_nodes = []
+          final_visibility = {}
+          default = :public
+
+          body.compact_child_nodes.each do |node|
+            case node
+            when Prism::DefNode
+              def_nodes << node
+              final_visibility[node.name] = default
+            when Prism::CallNode
+              default = apply_visibility_call(node, default, def_nodes, final_visibility)
             end
           end
 
-          [private_names.to_set, callback_names.to_set]
+          [def_nodes, final_visibility]
         end
 
-        # Returns the new visibility scope state after observing `node`. Bare `private` / `protected` /
-        # `public` switch state; the `private :foo` arg-bearing form does NOT (already handled by
-        # `collect_visibility_and_callbacks`).
-        def next_visibility(node, current)
-          return current unless node.is_a?(Prism::CallNode)
-          return current unless node.receiver.nil?
-          return current unless (args = node.arguments&.arguments).nil? || args.empty?
-
-          case node.name
-          when :private then :private
-          when :protected then :protected
-          when :public then :public
-          else current
+        # Applies one receiverless `public` / `private` / `protected` call and returns the (possibly new) default.
+        def apply_visibility_call(node, default, def_nodes, final_visibility)
+          return default unless node.receiver.nil? && VISIBILITY_KEYWORDS.include?(node.name)
+
+          args = node.arguments&.arguments || []
+          return node.name if args.empty?
+
+          args.flat_map { |arg| arg.is_a?(Prism::ArrayNode) ? arg.elements : [arg] }.each do |arg|
+            if arg.is_a?(Prism::DefNode)
+              def_nodes << arg
+              final_visibility[arg.name] = node.name
+            elsif (name = Rigor::Source::Literals.symbol_or_string(arg))
+              final_visibility[name] = node.name
+            end
           end
+          default
         end
 
         def build_class_entry(class_name, file_path, def_nodes, includes = [], module_actions = {})

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

@@ -52,13 +52,32 @@ module Rigor
         # Bumped 2026-09-02 (#621) — mailer keys are de-rooted at the producer and a reopened class's
         # actions are UNIONed rather than clobbered, so a cached 0.4.0 index can be missing actions this
         # version knows about.
-        version: "0.5.0",
+        #
+        # Bumped 2026-10-23 (#2308) — a method after a bare `protected` is no longer an action, so a cached 0.5.0
+        # index can list protected helpers as actions (and as missing-view candidates).
+        version: "0.5.1",
         description: "Validates ActionMailer call shape and view template existence.",
         config_schema: {
           "mailer_search_paths" => { kind: :array, default: ["app/mailers"] },
           "mailer_base_classes" => { kind: :array, default: %w[ApplicationMailer ActionMailer::Base] },
           "views_root" => { kind: :string, default: "app/views" }
         },
+        # ADR-125 (#575, #2308) — a mailer instance serves exactly one action (`Mailer.welcome(...)` builds a
+        # fresh instance and runs that one method), so ivar writes in two different public actions are never live
+        # together and `def.ivar-write-mismatch` stops comparing them. `ActionMailer::Base` has no signature here;
+        # the rule matches an undeclared superclass by its written name.
+        per_invocation_classes: ["ActionMailer::Base"],
+        # A public method these macros name is a callback or a view helper, not an action: it runs inside
+        # whichever action triggers it (AbstractController::Callbacks / Helpers), so its writes stay compared with
+        # every action's. The actionpack list, plus the `*_deliver` callbacks (ActionMailer::Callbacks), which run
+        # on the action's own instance.
+        per_invocation_non_action_macros: %i[
+          before_action prepend_before_action append_before_action skip_before_action
+          after_action prepend_after_action append_after_action skip_after_action
+          around_action prepend_around_action append_around_action skip_around_action
+          before_deliver after_deliver around_deliver
+          helper_method
+        ],
         # ADR-103 WD10 (#387) — see {Effects} for what each row is and why.
         effect_root: "rails",
         effect_labels: ["rails.actionmailer.deliver"],

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

@@ -146,6 +146,19 @@ module Rigor
           # `sig/action_view.rbs` so the name resolves, open so the helper surface stays lenient.
           "ActionView::Base"
         ],
+        # ADR-125 (#575) — Rails instantiates a fresh controller per request and runs exactly one action on
+        # it, so ivar writes in two different public actions are never live together and
+        # `def.ivar-write-mismatch` stops comparing them. Neither root has a signature (see `sig/action_controller.rbs`
+        # for why); the rule matches an undeclared superclass by its written name.
+        per_invocation_classes: ["ActionController::Base", "ActionController::API"],
+        # A public method these macros name is a callback or a view helper, not an action: it runs inside
+        # whichever action triggers it, so its writes stay compared with every action's (#575's A1 decision).
+        per_invocation_non_action_macros: %i[
+          before_action prepend_before_action append_before_action skip_before_action
+          after_action prepend_after_action append_after_action skip_after_action
+          around_action prepend_around_action append_around_action skip_around_action
+          helper_method
+        ],
         # ADR-103 WD10 / WD14 (#387) — see {Effects} for what each row is and why.
         effect_root: "rails",
         effect_labels: %w[

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

@@ -97,8 +97,10 @@ module Rigor
 
       # Cached separately from `:job_index` because the two invalidate on different files: editing a
       # schedule changes which jobs are reached without touching `app/jobs` at all. The `watch:` roots the
-      # glob at the working directory so that CREATING a schedule file — not just editing one — is seen.
-      producer :recurring_jobs, watch: -> { [[".", *@recurring_paths]] } do |_params|
+      # glob at the working directory so that CREATING a schedule file — not just editing one — is seen. Each
+      # configured path is escaped to a literal name, so `recurring[1].yml` is watched as that file.
+      producer :recurring_jobs,
+               watch: -> { [[".", *@recurring_paths.map { |path| Rigor::RootedGlob.literal(path) }]] } do |_params|
         RecurringScan.new(
           io_boundary: io_boundary,
           recurring_paths: @recurring_paths

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

@@ -33,9 +33,11 @@ module Rigor
     # - `:authenticatable` — always-included base module
     #
     # The substrate's pre-pass scanner consults each module's RBS via `Environment::RbsLoader#instance_definition`
-    # to enumerate method names. A user project providing real Devise via Bundler will see methods like
-    # `valid_password?`, `send_reset_password_instructions`, etc. resolve through the synthetic-method
-    # tier without `call.undefined-method`.
+    # to enumerate method names, so it names only what the project's RBS declares. The `devise` gem ships no
+    # RBS and Rigor bundles none for `Devise::Models::*`: a project supplies those signatures (`signature_paths:`
+    # or an `rbs collection`), and only then do `valid_password?`, `send_reset_password_instructions`, etc.
+    # resolve through the synthetic-method tier. A name the model defines itself, or a project module it
+    # includes or prepends defines, is left to the project's definition.
     #
     # ## Precision tier
     #

data/plugins/rigor-dry-types/lib/rigor/plugin/dry_types.rb

@@ -120,16 +120,17 @@ module Rigor
 
       # The `watch:` glob tuples covering the scan's entire input — one `[root, pattern]` per project `paths:`
       # entry. A directory entry watches its whole `**/*.rb` subtree; a single-file `.rb` entry watches
-      # exactly that file (`[dir, basename]`). Roots are expanded to absolute paths by
-      # `Plugin::Base#watch_glob_entries`, so a relative CLI path (`app/models`) re-validates against the same
-      # tree from the project root on the next run. Co-extensive with {#scannable_paths}: every `.rb` the scan
-      # would read is watched, so any edit / addition / removal under those paths invalidates the cache.
+      # exactly that file (`[dir, basename]`, with the basename escaped so `[`, `{`, `*` or `?` match literally).
+      # Roots are expanded to absolute paths by `Plugin::Base#watch_glob_entries`, so a relative CLI path
+      # (`app/models`) re-validates against the same tree from the project root on the next run. Co-extensive
+      # with {#scannable_paths}: every `.rb` the scan would read is watched, so any edit / addition / removal
+      # under those paths invalidates the cache.
       def alias_watch_globs
         services.configuration.paths.filter_map do |entry|
           if io_boundary.directory?(entry)
             [entry, "**/*.rb"]
           elsif io_boundary.file?(entry) && entry.end_with?(".rb")
-            [File.dirname(entry), File.basename(entry)]
+            [File.dirname(entry), Rigor::RootedGlob.literal(File.basename(entry))]
           end
         end
       end

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

@@ -35,7 +35,8 @@ module Rigor
       #    LocalVariableReadNode. Composite receivers (`expect(foo.bar)`, `expect { ... }.to raise_error`)
       #    fall through.
       # 3. The matcher is one of the recognised forms above (`be_a` / `be_kind_of` / `be_instance_of` /
-      #    `be_an_instance_of` / `be_nil` / `eq(literal)` / `eql(literal)` / `match(/regex/)`).
+      #    `be_an_instance_of` / `be_nil` / `eq(literal)` / `eql(literal)` / `match(/regex/)`, the last a meet
+      #    with the local's members; see `regex_match_type`).
       #
       # ## Equality is the local's own method
       #
@@ -152,10 +153,7 @@ module Rigor
           when :eq, :eql
             equality_type_for_literal_arg(matcher, target_local, negative: negative, scope: scope)
           when :match
-            # `match(/regex/)` narrows x to String. `match("...")` or `match(arbitrary_object)` falls
-            # through — the broader matcher dispatch needs the receiver to be a String, but we can only
-            # assert that for a literal regex.
-            string_type_for_regex_arg(matcher)
+            regex_match_type(matcher, target_local, negative: negative, scope: scope)
           end
         end
 
@@ -293,15 +291,108 @@ module Rigor
           end
         end
 
-        def string_type_for_regex_arg(matcher)
+        # --- `match(/regex/)` (#2033) ---
+        #
+        # RSpec's `match` passes when `expected === actual`, when `actual == expected`, or when `actual` responds to
+        # `match` and `actual.match(expected)` is truthy. `Regexp#===` matches a Symbol by its name, so a Symbol
+        # passes too, and keeps being a Symbol. The positive fact is therefore a meet with the local's members, as
+        # `eq`'s is: a String or Symbol member is kept as it is, and a member of a core class that has no `match` or
+        # `to_str` and whose `==` never equals a Regexp (`nil`, `true`, `false`, the numerics) is dropped, unless the
+        # project defines one of those methods on it or a core ancestor. An `Object`, `BasicObject`, `Kernel` or
+        # `Comparable` member reads `String | Symbol` ({#module_match_member}); any other module means no fact. Any other member (a user class, `Dynamic`) may pass, and
+        # the analyzer emits no fact; so does a subject none of whose members can pass (a `nil` local stays `nil`). The negative form emits none either: a String that does not match passes
+        # `not_to match`, so nothing leaves the local.
+        REGEX_MATCH_KEPT_CLASSES = %w[String Symbol].freeze
+        REGEX_MATCH_METHODS = %i[match to_str].freeze
+        Ractor.make_shareable(REGEX_MATCH_KEPT_CLASSES)
+        Ractor.make_shareable(REGEX_MATCH_METHODS)
+        private_constant :REGEX_MATCH_KEPT_CLASSES, :REGEX_MATCH_METHODS
+
+        def regex_match_type(matcher, target_local, negative:, scope:)
+          return nil if negative || scope.nil?
+          return nil unless regex_literal_arg?(matcher)
+
+          current = scope.local(target_local)
+          return nil if current.nil?
+
+          members = current.is_a?(Rigor::Type::Union) ? current.members : [current]
+          kept = []
+          members.each do |member|
+            met = regex_match_member(member, scope)
+            return nil if met.equal?(UNDECIDED)
+
+            kept << met unless met.nil?
+          end
+          kept.empty? ? nil : Rigor::Type::Combinator.union(*kept)
+        end
+
+        def regex_literal_arg?(matcher)
           args = matcher.arguments&.arguments || []
-          return nil unless args.size == 1
+          args.size == 1 &&
+            (args.first.is_a?(Prism::RegularExpressionNode) || args.first.is_a?(Prism::InterpolatedRegularExpressionNode))
+        end
 
-          arg = args.first
-          return nil unless arg.is_a?(Prism::RegularExpressionNode) ||
-                            arg.is_a?(Prism::InterpolatedRegularExpressionNode)
+        # The member itself when it may pass, nil when it cannot, UNDECIDED when Rigor cannot tell.
+        def regex_match_member(member, scope)
+          module_member = module_match_member(member, scope)
+          return module_member unless module_member.nil?
 
-          Rigor::Type::Combinator.nominal_of("String")
+          class_name = member_class_name(member)
+          return UNDECIDED if class_name.nil?
+          return member if REGEX_MATCH_KEPT_CLASSES.include?(class_name)
+          return member if project_defines?(class_name, :==, scope)
+          return member if REGEX_MATCH_METHODS.any? { |name| project_defines_on_chain?(class_name, name, scope) }
+
+          nil
+        end
+
+        OPEN_SURFACE_CLASS_NAMES = %w[Object BasicObject].freeze
+        # The modules String's or Symbol's own ancestry includes (`Kernel`, `Comparable`), read from the running Ruby.
+        STRING_SYMBOL_MODULES = (String.ancestors + Symbol.ancestors).grep_v(Class).filter_map(&:name).uniq.freeze
+        Ractor.make_shareable(OPEN_SURFACE_CLASS_NAMES)
+        Ractor.make_shareable(STRING_SYMBOL_MODULES)
+        private_constant :OPEN_SURFACE_CLASS_NAMES, :STRING_SYMBOL_MODULES
+
+        # The meet for an `Object`, `BasicObject` or module member, or nil for any other member. Its instances may be
+        # anything, a `to_str` or `match` object included. A member that declares `match` or `to_str` itself (its
+        # signature, a core ancestor, or the project's source) is kept whole. `Object`, `BasicObject` and a module
+        # String or Symbol includes otherwise read `String | Symbol`, as the String they most often are, so a String
+        # method called after the matcher reports nothing. Any other module is UNDECIDED: a passing value may include
+        # it without being a String. (`approval-queue.d/regexp-match-open-surface-subject.md`, shared with #2256.)
+        def module_match_member(member, scope)
+          return nil unless member.is_a?(Rigor::Type::Nominal) && member.type_args.empty?
+
+          name = member.class_name
+          string_like = OPEN_SURFACE_CLASS_NAMES.include?(name) || STRING_SYMBOL_MODULES.include?(name)
+          return nil unless string_like || scope.environment&.rbs_module?(name)
+          return member if REGEX_MATCH_METHODS.any? { |method_name| declares_method?(name, method_name, scope) }
+          return UNDECIDED unless string_like
+
+          Rigor::Type::Combinator.union(Rigor::Type::Combinator.nominal_of("String"),
+                                        Rigor::Type::Combinator.nominal_of("Symbol"))
+        end
+
+        def declares_method?(name, method_name, scope)
+          project_defines_on_chain?(name, method_name, scope) ||
+            !Rigor::Reflection.instance_method_definition(name, method_name, scope: scope).nil?
+        end
+
+        # Each core class's (and `Object` / `BasicObject` / `Kernel`'s) runtime ancestor chain. The project's
+        # reopenings are looked up along it by name, since the scope's ancestry walk does not cross core classes:
+        # `class Numeric; def to_str` reaches a Float member, `module Kernel; def match` a nil one.
+        CORE_ANCESTOR_CHAINS = [*EQUALITY_CORE_CLASSES, Object, BasicObject, Kernel].to_h do |mod|
+          [mod.name, mod.ancestors.filter_map(&:name).freeze]
+        end.freeze
+        Ractor.make_shareable(CORE_ANCESTOR_CHAINS)
+        private_constant :CORE_ANCESTOR_CHAINS
+
+        # Whether the project's source defines `method_name` on `class_name` or an ancestor, core ones included: a
+        # `def`, an included module, or a `define_method`.
+        def project_defines_on_chain?(class_name, method_name, scope)
+          CORE_ANCESTOR_CHAINS.fetch(class_name, [class_name]).any? do |name|
+            !scope.user_def_through_ancestors(name, method_name).first.nil? ||
+              scope.discovered_method_through_ancestors?(name, method_name, :instance)
+          end
         end
 
         NO_LITERAL = Object.new.freeze

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

@@ -97,8 +97,10 @@ module Rigor
 
       # Cached separately from `:worker_index` because the two invalidate on different files: editing a
       # schedule changes which workers are reached without touching `app/workers` at all. The `watch:` roots
-      # the glob at the working directory so that CREATING a schedule file — not just editing one — is seen.
-      producer :scheduled_workers, watch: -> { [[".", *@schedule_paths]] } do |_params|
+      # the glob at the working directory so that CREATING a schedule file — not just editing one — is seen. Each
+      # configured path is escaped to a literal name, so `sidekiq[1].yml` is watched as that file.
+      producer :scheduled_workers,
+               watch: -> { [[".", *@schedule_paths.map { |path| Rigor::RootedGlob.literal(path) }]] } do |_params|
         ScheduleScan.new(
           io_boundary: io_boundary,
           schedule_paths: @schedule_paths

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

@@ -62,7 +62,7 @@ module Rigor
           if io_boundary.directory?(File.expand_path(entry))
             [entry, "**/*.rb"]
           elsif entry.end_with?(".rb") && io_boundary.file?(File.expand_path(entry))
-            [File.dirname(entry), File.basename(entry)]
+            [File.dirname(entry), Rigor::RootedGlob.literal(File.basename(entry))]
           end
         end
       end

data/sig/rigor/analysis/baseline.rbs

@@ -66,8 +66,9 @@ module Rigor
 
       # Always an Array of Bucket — `initialize` freezes what it is given and every caller hands it
       # Bucket instances (parse_row rows, from_diagnostics groups, `without`'s reject, or `[]`).
-      # sig-gen gap: #1154 — an `attr_reader` over an ivar assigned in `initialize` from a parameter
-      # is skipped (untyped return); the element type is hand-written.
+      # sig-gen gap: #2321 — `initialize` assigns `buckets.freeze`, an expression derived from the
+      # parameter rather than a bare read of it, so the reader is skipped (untyped return) and the element type
+      # is hand-written.
       attr_reader buckets: Array[Bucket]
 
       # `project_root` is `Pathname.new`'d, so a `Pathname` is accepted as well as a `String`

data/sig/rigor/effects/file_collection.rbs

@@ -45,16 +45,15 @@ module Rigor
       # The collection a file with nothing to say contributes.
       def self.empty: (?String? path) -> FileCollection
 
-      # sig-gen gap: #1154 — `initialize` freezes the kwarg tables rather than assigning them
-      # verbatim, so sig-gen proposes the default constant's shape for each reader.
       attr_reader path: String?
-      # sig-gen gap: #1154 — `{ "Class#m" => Summary }`.
+      # sig-gen gap: #2312 — `{ "Class#m" => Summary }`, through the private `freeze_table` helper, whose parameters
+      # are undeclared.
       attr_reader summaries: Hash[String, Summary]
-      # sig-gen gap: #1154 — `{ "Class#m" => [Edge] }`, sorted and de-duplicated.
+      # sig-gen gap: #2312 — `{ "Class#m" => [Edge] }`, sorted and de-duplicated.
       attr_reader edges: Hash[String, Array[Edge]]
-      # sig-gen gap: #1154 — `{ class_name => superclass_name }`, `OPAQUE_ANCESTOR` included.
+      # sig-gen gap: #2312 — `{ class_name => superclass_name }`, `OPAQUE_ANCESTOR` included.
       attr_reader superclasses: Hash[String, String]
-      # sig-gen gap: #1154 — `{ class_name => [module_name] }`, include/prepend merged.
+      # sig-gen gap: #2312 — `{ class_name => [module_name] }`, include/prepend merged.
       attr_reader includes: Hash[String, Array[String]]
 
       def initialize: (?path: String?, ?summaries: Hash[String, Summary],