rigortype 0.4.3 → 0.4.4

data/lib/rigor/sig_gen/layout_index.rb

@@ -20,7 +20,26 @@ module Rigor
     # First-found wins on duplicate declarations across files; RBS itself allows the same class to be declared
     # in multiple files for additive member contributions, but the writer only needs one canonical target per
     # class.
+    #
+    # ADR-122 WD2 adds the member level: `(class_name, method_name, kind) → sig_file_path`, so a member the project
+    # already declares in one file is updated there rather than inserted a second time into the class's
+    # first-found file (#1488).
     class LayoutIndex
+      # The `[method_name, kind]` keys a member declaration answers for, `kind` being `:instance` or
+      # `:singleton`. A `def self?.f` answers for both kinds; an `attr_accessor` answers for its reader and its
+      # writer. Shared with {Writer}, which asks the same question of the target file it is merging into.
+      def self.member_keys(member)
+        case member
+        when RBS::AST::Members::MethodDefinition
+          kinds = member.kind == :singleton_instance ? %i[instance singleton] : [member.kind]
+          kinds.map { |kind| [member.name, kind] }
+        when RBS::AST::Members::AttrReader then [[member.name, member.kind]]
+        when RBS::AST::Members::AttrWriter then [[:"#{member.name}=", member.kind]]
+        when RBS::AST::Members::AttrAccessor then [[member.name, member.kind], [:"#{member.name}=", member.kind]]
+        else []
+        end
+      end
+
       # @param signature_paths —
       #   the `.rigor.yml`-configured signature directories.
       #   When `nil` or empty, falls back to `<project_root>/sig`
@@ -29,6 +48,7 @@ module Rigor
       def initialize(signature_paths:, project_root: Dir.pwd)
         @signature_paths = resolve_paths(signature_paths, project_root)
         @index = nil
+        @members = nil
       end
 
       # @param class_name — fully-qualified Ruby class
@@ -40,6 +60,13 @@ module Rigor
         index[class_name]
       end
 
+      # @return absolute path of the first sig file (in the same order as {#file_for}) that declares
+      #   `method_name` of `kind` on `class_name`, or `nil` when no file does.
+      def member_file_for(class_name, method_name, kind)
+        index
+        @members[[class_name, method_name, kind]]
+      end
+
       def empty?
         index.empty?
       end
@@ -60,6 +87,7 @@ module Rigor
 
       def build_index
         accumulator = {}
+        @members = {}
         Array(@signature_paths).each do |dir|
           base = Pathname(dir)
           next unless base.directory?
@@ -68,6 +96,7 @@ module Rigor
             index_file(Pathname(rbs_file), accumulator)
           end
         end
+        @members.freeze
         accumulator.freeze
       end
 
@@ -97,6 +126,13 @@ module Rigor
         local_name = decl.name.to_s.sub(/\A::/, "")
         full = prefix.empty? ? local_name : "#{prefix.join('::')}::#{local_name}"
         accumulator[full] ||= rbs_path
+        decl.members.each do |member|
+          # An `overloading?` member (`def f: ... | ...`) adds to a declaration elsewhere; routing a candidate to
+          # it would replace the user's overload.
+          next if member.is_a?(RBS::AST::Members::MethodDefinition) && member.overloading?
+
+          self.class.member_keys(member).each { |name, kind| @members[[full, name, kind]] ||= rbs_path }
+        end
 
         record_decls(decl.members, prefix + [local_name], rbs_path, accumulator)
       end

data/lib/rigor/sig_gen/method_candidate.rb

@@ -68,6 +68,14 @@ module Rigor
         @declared_annotations + @annotations + [@rbs].compact
       end
 
+      # The RBS member kind `rbs` declares: `:singleton_instance` for a `def self?.` line (a `module_function`
+      # method, whose `kind` stays `:instance`), `kind` otherwise. The writer replaces only a member of this
+      # kind, so an overwrite neither drops a `self?.` member's singleton half nor adds one beside a split
+      # `def self.f` / `def f` pair (#1488).
+      def rbs_kind
+        kind == :instance && rbs.to_s.start_with?("def self?.") ? :singleton_instance : kind
+      end
+
       # A copy carrying a different annotation decision. The generator's effect pass rebuilds rather than
       # mutates, because a candidate is frozen the moment it is built.
       def with_effect_annotation(annotations, reason)

data/lib/rigor/sig_gen/path_mapper.rb

@@ -37,8 +37,11 @@ module Rigor
       #   returned instead of the 1:1 mirror.
       # @return absolute path of the target `.rbs`
       #   file for the candidate.
-      def target_for(source_path, class_name: nil)
-        existing = existing_target_for(class_name)
+      #
+      # A member the signature tree already declares (`method_name` / `kind`, ADR-122 WD2) is routed to the file
+      # that declares it, even when another file declares its class first (#1488).
+      def target_for(source_path, class_name: nil, method_name: nil, kind: nil)
+        existing = existing_member_target_for(class_name, method_name, kind) || existing_target_for(class_name)
         return existing if existing
 
         rel_to_root = source_relative_to_root(source_path)
@@ -46,6 +49,19 @@ module Rigor
         sig_root_dir / "#{stripped.sub_ext('')}.rbs"
       end
 
+      # `kind` may be `:singleton_instance` (a `def self?.` candidate), which routes to whichever file declares
+      # either half.
+      def existing_member_target_for(class_name, method_name, kind)
+        return nil if class_name.nil? || method_name.nil? || @layout_index.nil?
+
+        kinds = kind == :singleton_instance ? %i[instance singleton] : [kind]
+        kinds.each do |k|
+          file = @layout_index.member_file_for(class_name, method_name, k)
+          return file if file
+        end
+        nil
+      end
+
       def existing_target_for(class_name)
         return nil if class_name.nil? || @layout_index.nil?
 

data/lib/rigor/sig_gen/writer.rb

@@ -4,6 +4,7 @@ require "fileutils"
 require "rbs"
 
 require_relative "classification"
+require_relative "layout_index"
 require_relative "superclass_spelling"
 require_relative "write_result"
 
@@ -62,8 +63,10 @@ module Rigor
 
         @global_namespace_kinds = build_namespace_kinds(candidates)
         @global_superclasses = build_superclasses(candidates)
-        emittable.group_by { |c| @path_mapper.target_for(c.path, class_name: c.class_name) }
-                 .map { |target, group| write_target(target, group) }
+        grouped = emittable.group_by do |c|
+          @path_mapper.target_for(c.path, class_name: c.class_name, method_name: c.method_name, kind: c.rbs_kind)
+        end
+        grouped.map { |target, group| write_target(target, group) }
       end
 
       # @param candidates — only
@@ -562,7 +565,10 @@ module Rigor
           state.applied.concat(methods)
           insert_namespace_chain(state, class_name, kinds, supers, methods)
         else
-          state.source = merge_into_existing_class(state.source, decl, methods, state)
+          # A class reopened in one file answers for every member of every opening, not just the first one's
+          # (#1488): a member another opening declares is user-authored, not new.
+          declared = find_class_decls(state.decls, class_name).flat_map { |d| collect_member_pairs(d) }
+          state.source = merge_into_existing_class(state.source, decl, methods, state, declared)
           state.decls = parse_signature(state.source) || state.decls
         end
       end
@@ -589,12 +595,25 @@ module Rigor
         nil
       end
 
+      # Every declaration of `qualified_name` in the file, in {#find_class_decl}'s order (so the first is the one
+      # it returns).
+      def find_class_decls(decls, qualified_name, prefix = [], found = [])
+        decls.each do |decl|
+          next unless decl.is_a?(RBS::AST::Declarations::Class) || decl.is_a?(RBS::AST::Declarations::Module)
+
+          local = decl.name.to_s.sub(/\A::/, "")
+          full = prefix.empty? ? local : "#{prefix.join('::')}::#{local}"
+          found << decl if full == qualified_name
+          find_class_decls(decl.members, qualified_name, prefix + [local], found)
+        end
+        found
+      end
+
       def ends_with_newline?(source)
         source.end_with?("\n")
       end
 
-      def merge_into_existing_class(source, decl, methods, state)
-        existing_pairs = collect_member_pairs(decl)
+      def merge_into_existing_class(source, decl, methods, state, existing_pairs)
         new_methods, conflicting = partition_against_existing(methods, existing_pairs)
 
         source = insert_into_class(source, decl, new_methods)
@@ -617,31 +636,20 @@ module Rigor
       end
 
       # Returns a list of `[method_name (Symbol), kind (Symbol)]` pairs for every method-like member in the
-      # declaration. ADR-14 slice 4 recognises `MethodDefinition`'s `:instance` / `:singleton` kind plus the
-      # three `attr_*` declaration kinds so a source-side `attr_reader :name` and an RBS-side
-      # `attr_reader name: T` are treated as the same member (i.e. user-authored).
+      # declaration ({LayoutIndex.member_keys}). ADR-14 slice 4 recognises the three `attr_*` declaration kinds
+      # so a source-side `attr_reader :name` and an RBS-side `attr_reader name: T` are treated as the same member
+      # (i.e. user-authored); a `def self?.f` counts as both an instance and a singleton `f` (#1488).
       def collect_member_pairs(decl)
-        pairs = []
-        decl.members.each { |m| collect_pairs_for_member(m, pairs) }
-        pairs
-      end
-
-      def collect_pairs_for_member(member, pairs)
-        case member
-        when RBS::AST::Members::MethodDefinition
-          pairs << [member.name, member.kind]
-        when RBS::AST::Members::AttrReader
-          pairs << [member.name, :instance]
-        when RBS::AST::Members::AttrWriter
-          pairs << [:"#{member.name}=", :instance]
-        when RBS::AST::Members::AttrAccessor
-          pairs << [member.name, :instance]
-          pairs << [:"#{member.name}=", :instance]
-        end
+        decl.members.flat_map { |m| LayoutIndex.member_keys(m) }
       end
 
+      # A `def self?.f` candidate conflicts with a declared instance OR singleton `f`: inserting it beside a lone
+      # `def self.f` (or `def f`) would declare that half twice (#1488).
       def partition_against_existing(methods, existing_pairs)
-        methods.partition { |c| !existing_pairs.include?([c.method_name, c.kind]) }
+        methods.partition do |c|
+          kinds = c.rbs_kind == :singleton_instance ? %i[instance singleton] : [c.kind]
+          kinds.none? { |kind| existing_pairs.include?([c.method_name, kind]) }
+        end
       end
 
       # Inserts each new method line one column before the class declaration's `end` keyword. The insertion
@@ -710,7 +718,7 @@ module Rigor
       # part of the contract. A candidate that keeps `void` is still eligible, which is what case 2 is for —
       # the `initialize` stub is always spelled `-> void`.
       def replaces_declared_void?(candidate, decl)
-        member = find_method_member(decl, candidate.method_name, candidate.kind)
+        member = find_method_member(decl, candidate)
         return false if member.nil?
 
         declared_void = member.overloads.any? do |overload|
@@ -722,7 +730,7 @@ module Rigor
       # Compares the existing member's source-side RBS text against the candidate's proposed RBS text
       # ({.fewer_untyped?}).
       def tightens_untyped?(candidate, decl, source)
-        member = find_method_member(decl, candidate.method_name, candidate.kind)
+        member = find_method_member(decl, candidate)
         return false if member.nil?
 
         self.class.fewer_untyped?(candidate.rbs, source[member.location.start_pos...member.location.end_pos])
@@ -737,7 +745,7 @@ module Rigor
       # the same method (ADR-112 WD4), which it replaces in the inline attribute's own spelling; an
       # `overloading?` member (`| ...`) is never its target.
       def replaceable_member(decl, candidate)
-        member = find_method_member(decl, candidate.method_name, candidate.kind)
+        member = find_method_member(decl, candidate)
         return member unless candidate.classification == Classification::INLINE_OVERWRITE
 
         member = nil if member.respond_to?(:overloading?) && member.overloading?
@@ -746,15 +754,20 @@ module Rigor
 
       def find_attr_member(decl, method_name, kind)
         decl.members.find do |m|
-          pairs = []
-          collect_pairs_for_member(m, pairs) unless m.is_a?(RBS::AST::Members::MethodDefinition)
-          m.respond_to?(:kind) && m.kind == kind && pairs.any? { |name, _| name == method_name }
+          next false if m.is_a?(RBS::AST::Members::MethodDefinition)
+
+          LayoutIndex.member_keys(m).include?([method_name, kind])
         end
       end
 
-      def find_method_member(decl, method_name, kind)
+      # Matches on the candidate's {MethodCandidate#rbs_kind}, so a `def self?.f` proposal finds only a
+      # `def self?.f` member: a `def f` beside a `def self.f`, or a `def self?.f` under a plain `def f`
+      # proposal, is left as the user wrote it. An `overloading?` member (`def f: ... | ...`) adds to a
+      # declaration elsewhere rather than being one, so it is never replaced (#1488).
+      def find_method_member(decl, candidate)
         decl.members.find do |m|
-          m.is_a?(RBS::AST::Members::MethodDefinition) && m.name == method_name && m.kind == kind
+          m.is_a?(RBS::AST::Members::MethodDefinition) && m.name == candidate.method_name &&
+            m.kind == candidate.rbs_kind && !m.overloading?
         end
       end
 

data/lib/rigor/version.rb

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

data/plugins/rigor-dry-schema/lib/rigor/plugin/dry_schema.rb

@@ -168,10 +168,14 @@ module Rigor
 
       # ADR-45 WD1b (#613 / #630) — the classification probes go through the boundary, so an entry that
       # is not there yet (or stops being a directory) is a recorded dependency of the scan's input set.
+      # #1803 — so is the walk: `IoBoundary#glob` records which `.rb` files the entry holds, and a file
+      # `exclude:` keeps out of analysis, which no analysed-file row covers, reaches the run-result caches
+      # when it appears or disappears. The matches are spelled under `entry`, as `Dir.glob` spelled them.
       def scannable_paths(services)
         @scannable_paths ||= services.configuration.paths.flat_map do |entry|
           if io_boundary.directory?(entry)
-            Dir.glob(File.join(entry, "**", "*.rb"), sort: true)
+            prefix = "#{File.absolute_path(entry)}/"
+            io_boundary.glob(entry, "**/*.rb").map { |path| File.join(entry, path.delete_prefix(prefix)) }
           elsif io_boundary.file?(entry) && entry.end_with?(".rb")
             [entry]
           else

data/plugins/rigor-dry-validation/lib/rigor/plugin/dry_validation.rb

@@ -142,10 +142,14 @@ module Rigor
 
       # ADR-45 WD1b (#613 / #630) — the classification probes go through the boundary, so an entry that
       # is not there yet (or stops being a directory) is a recorded dependency of the scan's input set.
+      # #1803 — so is the walk: `IoBoundary#glob` records which `.rb` files the entry holds, and a file
+      # `exclude:` keeps out of analysis, which no analysed-file row covers, reaches the run-result caches
+      # when it appears or disappears. The matches are spelled under `entry`, as `Dir.glob` spelled them.
       def scannable_paths(services)
         @scannable_paths ||= services.configuration.paths.flat_map do |entry|
           if io_boundary.directory?(entry)
-            Dir.glob(File.join(entry, "**", "*.rb"), sort: true)
+            prefix = "#{File.absolute_path(entry)}/"
+            io_boundary.glob(entry, "**/*.rb").map { |path| File.join(entry, path.delete_prefix(prefix)) }
           elsif io_boundary.file?(entry) && entry.end_with?(".rb")
             [entry]
           else

data/plugins/rigor-ffi/lib/rigor/plugin/ffi/discoverer.rb

@@ -5,13 +5,20 @@ require "prism"
 module Rigor
   module Plugin
     class FFI < Base
+      # Issue #1803 — the walk lists and reads through the plugin's {Rigor::Plugin::IoBoundary} (`io:`), so every
+      # `.rb` the catalog was built from is a dependency row of the `:ffi_catalog` producer's cache entry and of
+      # every run-result cache built on the run. The producer declares no `watch:`, so before this its entry
+      # carried no row at all and was served after any edit, an analysed file's included, until `--no-cache`.
       class Discoverer
-        def self.discover(root:)
-          new(root: root).discover
+        RUBY_GLOB = "**/*.rb"
+
+        def self.discover(root:, io:)
+          new(root: root, io: io).discover
         end
 
-        def initialize(root:)
+        def initialize(root:, io:)
           @root = root
+          @io = io
         end
 
         def discover
@@ -24,7 +31,7 @@ module Rigor
           callbacks = {}
 
           ruby_files.each do |file_path|
-            parse_result = Prism.parse_file(file_path)
+            parse_result = parse(file_path)
             next unless parse_result.value
 
             walk_tree(parse_result.value, nil) do |node, mod_name|
@@ -61,9 +68,24 @@ module Rigor
         private
 
         def ruby_files
-          return [] unless @root && File.directory?(@root)
+          return [] unless @root && @io.directory?(@root.to_s)
+
+          boundary_glob.reject { |p| p.include?("/vendor/") || p.include?("/.git/") }
+        end
+
+        # One `:names` `**/*.rb` row over the root, `vendor/` included: a per-entry walk that skipped it recorded
+        # names only, so a top-level entry that changed kind under the same name went unseen. The boundary
+        # answers absolute paths; they are spelled back under `@root` as `Dir.glob` spells them, so the filter
+        # above sees the same strings it always did.
+        def boundary_glob
+          root = @root.to_s
+          prefix = "#{File.absolute_path(root)}/"
+          @io.glob(root, RUBY_GLOB).map { |path| File.join(root, path.delete_prefix(prefix)) }
+        end
 
-          Dir.glob(File.join(@root, "**", "*.rb")).reject { |p| p.include?("/vendor/") || p.include?("/.git/") }
+        # The glob's rows record which files match; this read's row carries an edit.
+        def parse(file_path)
+          Prism.parse(@io.read_file(file_path))
         end
 
         def walk_tree(node, current_module, &)

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

@@ -32,7 +32,7 @@ module Rigor
 
       producer :ffi_catalog do
         root = config["root"] || Dir.pwd
-        Discoverer.discover(root: root)
+        Discoverer.discover(root: root, io: io_boundary)
       end
 
       # Dynamic return rule for attached FFI functions

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

@@ -151,10 +151,14 @@ module Rigor
 
       # ADR-45 WD1b (#613 / #630) — the classification probes go through the boundary, so an entry that
       # is not there yet (or stops being a directory) is a recorded dependency of the scan's input set.
+      # #1803 — so is the walk: `IoBoundary#glob` records which `.rb` files the entry holds, and a file
+      # `exclude:` keeps out of analysis, which no analysed-file row covers, reaches the run-result caches
+      # when it appears or disappears. The matches are spelled under `entry`, as `Dir.glob` spelled them.
       def scannable_paths(services)
         @scannable_paths ||= services.configuration.paths.flat_map do |entry|
           if io_boundary.directory?(entry)
-            Dir.glob(File.join(entry, "**", "*.rb"), sort: true)
+            prefix = "#{File.absolute_path(entry)}/"
+            io_boundary.glob(entry, "**/*.rb").map { |path| File.join(entry, path.delete_prefix(prefix)) }
           elsif io_boundary.file?(entry) && entry.end_with?(".rb")
             [entry]
           else

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

@@ -18,7 +18,8 @@ module Rigor
       #   Nominal[T] uniformly, so the distinction with `be_a` is observed at the carrier level but not the
       #   runtime).
       # - `be_nil` — narrows `x` to `Constant<nil>`.
-      # - `eq(LITERAL)` for a literal-value argument — narrows `x` to `Constant<literal>`.
+      # - `eq(LITERAL)` / `eql(LITERAL)` for a literal-value argument — meets `x` with `Constant<literal>`
+      #   (see "Equality is the local's own method" below).
       #
       # The matchers below this floor (`be_truthy` / `be_falsey` / `be_within` / `be > / < / >=` /
       # `include` / `start_with` / `match(regex)` / `raise_error` / receive-style mocks) require either
@@ -35,16 +36,47 @@ module Rigor
       #    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/)`).
+      #
+      # ## Equality is the local's own method
+      #
+      # `expect(x).to eq(lit)` passes when `x == lit` and `eql(lit)` when `x.eql?(lit)`: the local is the
+      # receiver, so its own `==` / `eql?` decides, and a class with a custom `==` can equal even a `nil`,
+      # boolean or Symbol literal. A positive equality fact therefore never replaces the local's type (issue
+      # #1807). It is a meet with the local's current type, member by member:
+      #
+      # - a member of the literal's own core class (`Integer`, `Float`, `String`, `Symbol`, `NilClass`,
+      #   `TrueClass`, `FalseClass`) narrows to the literal, a refinement of that class (`non-empty-string`,
+      #   `decimal-int-string`, `non-zero-int`) included; a `Constant` member is kept when it equals the
+      #   literal and dropped otherwise; a `Float` member meeting `0.0` (which `-0.0` also equals) is kept;
+      # - a core numeric member of another class (`Integer`, `Float`, `Rational`, `Complex`) is kept under
+      #   `eq` (`1.0 == 1`) and dropped under `eql` (`1.0.eql?(1)` is false);
+      # - any other core member (`nil` against `9`, a `String` against `:a`) is dropped: built-in equality
+      #   across those classes is false;
+      # - a member of a core class is kept unnarrowed when the project's source defines the operator on that
+      #   class or on a core ancestor up to the one that owns the operator at runtime (`class Symbol; def
+      #   ==`, `class Numeric; def eql?` for an `Integer`, `class Object; def ==` for `nil`): its own method
+      #   decides.
+      #
+      # When any member is `Dynamic` or of any other class (a user class, `Object`, `Numeric`, `BigDecimal`),
+      # the analyzer emits no fact and the local keeps its type. It also emits none when the project's source
+      # defines the operator on the literal's class or those ancestors of it — a core `==` calls back into the
+      # literal's (`Integer#==` runs `other == self` for a non-numeric argument, `String#==` for one that
+      # responds to `to_str`), so a custom one there can make any member equal — and for an unbound local,
+      # when no member survives, and without a scope. A reopening that defines other methods only
+      # (`class String; def shout`) does not count.
+      #
+      # The negative forms (`not_to` / `to_not`) still emit a negative `Constant` fact, which the engine's fact
+      # narrowing does not act on, so the local keeps its type there too.
       module MatcherAnalyzer
         module_function
 
         # @param call_node — the call whose contribution we're computing. Returns nil when
         #   the call shape does not match `expect(local).to matcher`.
-        # @param environment — the surrounding environment used to resolve a
-        #   matcher's class-name argument to a `Type::Nominal`. When nil, class-name resolution falls back
-        #   to a bare `Nominal[<name>]` carrier (sound — the receiver constant may be a user class not in
-        #   RBS).
-        def contribution_for(call_node, environment:)
+        # @param scope — the scope at the call, or nil. Its environment resolves a matcher's class-name
+        #   argument to a `Type::Nominal` (without one, a bare `Nominal[<name>]` carrier — sound, the receiver
+        #   constant may be a user class not in RBS); the local's current type in it is what a positive
+        #   `eq` / `eql` fact meets (without one, no such fact).
+        def contribution_for(call_node, scope:)
           verb = assertion_verb(call_node)
           return nil if verb.nil?
           return nil unless call_node.receiver.is_a?(Prism::CallNode)
@@ -58,14 +90,15 @@ module Rigor
           matcher = matcher_call(call_node)
           return nil if matcher.nil?
 
-          narrowed_type = narrowed_type_for(matcher, environment: environment)
+          negative = verb == :negative
+          narrowed_type = narrowed_type_for(matcher, target_local, negative: negative, scope: scope)
           return nil if narrowed_type.nil?
 
           fact = Rigor::FlowContribution::Fact.new(
             target_kind: :local,
             target_name: target_local,
             type: narrowed_type,
-            negative: verb == :negative
+            negative: negative
           )
           Rigor::FlowContribution.new(post_return_facts: [fact])
         end
@@ -105,7 +138,8 @@ module Rigor
         # narrowed type. Returns nil when the matcher is
         # unrecognised or its argument shape does not match the
         # supported envelope.
-        def narrowed_type_for(matcher, environment:)
+        def narrowed_type_for(matcher, target_local, negative:, scope:)
+          environment = scope&.environment
           return nil unless matcher.is_a?(Prism::CallNode) && matcher.receiver.nil?
 
           case matcher.name
@@ -116,7 +150,7 @@ module Rigor
 
             Rigor::Type::Combinator.constant_of(nil)
           when :eq, :eql
-            constant_type_for_literal_arg(matcher)
+            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
@@ -140,14 +174,123 @@ module Rigor
           end
         end
 
-        def constant_type_for_literal_arg(matcher)
+        def equality_type_for_literal_arg(matcher, target_local, negative:, scope:)
           args = matcher.arguments&.arguments || []
           return nil unless args.size == 1
 
           literal_value = literal_value_for(args.first)
           return nil if literal_value.equal?(NO_LITERAL)
+          return Rigor::Type::Combinator.constant_of(literal_value) if negative
+          return nil if scope.nil?
+
+          operator = matcher.name == :eql ? :eql? : :==
+          equality_meet(scope.local(target_local), literal_value, operator, scope)
+        end
+
+        # --- equality meet (`eq` / `eql`; see "Equality is the local's own method") ---
+
+        # Core classes whose `==` / `eql?` Rigor can evaluate against a literal: across any two of them the
+        # answer is built in, unless the project defines the operator on one of them.
+        EQUALITY_CORE_CLASSES = [Integer, Float, Rational, Complex, String, Symbol, NilClass, TrueClass,
+                                 FalseClass].freeze
+        Ractor.make_shareable(EQUALITY_CORE_CLASSES)
+        private_constant :EQUALITY_CORE_CLASSES
+
+        NUMERIC_CLASS_NAMES = %w[Integer Float Rational Complex].freeze
+        Ractor.make_shareable(NUMERIC_CLASS_NAMES)
+        private_constant :NUMERIC_CLASS_NAMES
+
+        # For each core class and operator, the class and its ancestors up to and including the one that owns
+        # the operator at runtime (`Integer#eql?` is `Numeric`'s, `nil == x` is `BasicObject`'s). A project
+        # definition on any of them is the method the member runs; one above the owner is shadowed by it.
+        OPERATOR_OWNER_CHAINS = EQUALITY_CORE_CLASSES.each_with_object({}) do |klass, chains|
+          %i[== eql?].each do |operator|
+            ancestors = klass.ancestors
+            owner_index = ancestors.index(klass.instance_method(operator).owner)
+            chains[[klass.name, operator]] = ancestors[0..owner_index].map(&:name).freeze
+          end
+        end.freeze
+        Ractor.make_shareable(OPERATOR_OWNER_CHAINS)
+        private_constant :OPERATOR_OWNER_CHAINS
+
+        # Marks a member whose equality with the literal cannot be decided, so the whole meet gives up.
+        UNDECIDED = Object.new.freeze
+        private_constant :UNDECIDED
+
+        # The members of `current` that `x <operator> literal` admits, narrowed where the member's class is
+        # the literal's, or nil when any member is undecided or none survives. An unbound local (nil) is one
+        # undecided member.
+        def equality_meet(current, literal, operator, scope)
+          return nil if project_defines?(literal.class.name, operator, scope)
+
+          members = current.is_a?(Rigor::Type::Union) ? current.members : [current]
+          kept = []
+          members.each do |member|
+            met = meet_member(member, literal, operator, scope)
+            return nil if met.equal?(UNDECIDED)
 
-          Rigor::Type::Combinator.constant_of(literal_value)
+            kept << met unless met.nil?
+          end
+          return nil if kept.empty?
+
+          Rigor::Type::Combinator.union(*kept)
+        end
+
+        # One member's part of the meet: the member itself or its narrowing, nil when no value of it equals
+        # the literal, or UNDECIDED.
+        def meet_member(member, literal, operator, scope)
+          class_name = member_class_name(member)
+          return UNDECIDED if class_name.nil?
+          return member if project_defines?(class_name, operator, scope)
+
+          case member
+          when Rigor::Type::Constant then member.value.public_send(operator, literal) ? member : nil
+          when Rigor::Type::IntegerRange
+            literal.is_a?(Integer) && !member.covers?(literal) ? nil : meet_class(member, class_name, literal, operator)
+          else meet_class(member, class_name, literal, operator)
+          end
+        end
+
+        # The core class a member's values belong to, or nil for a member that is not wholly of one. A
+        # refinement (`Difference`, `Refined`) belongs to its base's class, an `Intersection` to the class all
+        # its members share.
+        def member_class_name(member)
+          case member
+          when Rigor::Type::Difference, Rigor::Type::Refined then member_class_name(member.base)
+          when Rigor::Type::Intersection
+            names = member.members.map { |part| member_class_name(part) }.uniq
+            names.size == 1 ? names.first : nil
+          when Rigor::Type::FloatRange then "Float"
+          when Rigor::Type::Constant
+            klass = EQUALITY_CORE_CLASSES.find { |core| member.value.instance_of?(core) }
+            klass&.name
+          when Rigor::Type::IntegerRange then "Integer"
+          when Rigor::Type::Nominal
+            name = member.class_name
+            member.type_args.empty? && EQUALITY_CORE_CLASSES.any? { |core| core.name == name } ? name : nil
+          end
+        end
+
+        def meet_class(member, class_name, literal, operator)
+          literal_class = literal.class.name
+          if class_name == literal_class
+            literal.is_a?(Float) && literal.zero? ? member : Rigor::Type::Combinator.constant_of(literal)
+          elsif NUMERIC_CLASS_NAMES.include?(class_name) && NUMERIC_CLASS_NAMES.include?(literal_class)
+            operator == :== ? member : nil
+          end
+        end
+
+        # Whether the project's source defines `operator` on the core class `class_name` or on a core ancestor
+        # up to the operator's runtime owner (OPERATOR_OWNER_CHAINS): a reopening's `def`, an included or
+        # prepended project module, a `define_method`. The def-node walk sees other files' `def`s and records
+        # the dependency on them; the discovery table adds `define_method`. An RBS declaration is not
+        # consulted: once the project reopens `String` for anything, `String#==`'s declaring owner is a
+        # project class, which says nothing about who wrote `==`.
+        def project_defines?(class_name, operator, scope)
+          OPERATOR_OWNER_CHAINS.fetch([class_name, operator]).any? do |name|
+            !scope.user_def_through_ancestors(name, operator).first.nil? ||
+              scope.discovered_method_through_ancestors?(name, operator, :instance)
+          end
         end
 
         def string_type_for_regex_arg(matcher)