rigortype 0.4.2 → 0.4.4

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)

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

@@ -86,7 +86,7 @@ module Rigor
       # ADR-37 slice 2 — matcher narrowing (`expect(x).to be_a(T)` → `post_return_facts` on `x`),
       # method-gated by the engine on the expectation verbs.
       narrowing_facts methods: %i[to not_to to_not] do |call_node, scope|
-        MatcherAnalyzer.contribution_for(call_node, environment: scope&.environment)&.post_return_facts
+        MatcherAnalyzer.contribution_for(call_node, scope: scope)&.post_return_facts
       end
 
       # ADR-52 slice 5a — binds local reads in `it` / spec bodies to their `let(:name) { ... }` block's
@@ -98,13 +98,15 @@ module Rigor
         let_binding_return_type(call_node, scope)
       end
 
-      # ADR-88 WD1 — both contributions are per-file: the matcher narrowing facts come from the call's own AST,
-      # and the `let`-binding return types come from each spec file's OWN `describe`/`let` structure (`let` is
-      # file-scoped). A spec file's edit changes its own content (re-analysed already). The one cross-file input
-      # — the optional factorybot `:factory_index` fact this plugin consumes — is itself an ADR-9 publication
-      # captured in the incremental fact-surface digest via factorybot's own channel, so it need not appear
-      # here. A stable sentinel declares "no OWN cross-file fact surface", keeping the plugin
-      # incremental-capable; `--verify-incremental` backstops the claim.
+      # ADR-88 WD1 — both contributions are per-file: the matcher narrowing facts come from the call's own AST
+      # and, for `eq` / `eql`, from the local's current type and the scope's project discovery (whether the
+      # project defines `==` / `eql?` on a core class); the `let`-binding return types come from each spec
+      # file's OWN `describe`/`let` structure (`let` is file-scoped). A spec file's edit changes its own
+      # content (re-analysed already). The one cross-file input — the optional factorybot `:factory_index`
+      # fact this plugin consumes — is itself an ADR-9 publication captured in the incremental fact-surface
+      # digest via factorybot's own channel, so it need not appear here. A stable sentinel declares "no OWN
+      # cross-file fact surface", keeping the plugin incremental-capable; `--verify-incremental` backstops
+      # the claim.
       def incremental_state_fingerprint
         "per-file-lets"
       end

data/sig/rigor/scope.rbs

@@ -247,6 +247,7 @@ module Rigor
     def optimistic_local_miss: (String | Symbol name) -> Object?
     def optimistic_ivar_miss: (String | Symbol name) -> Object?
     def with_local: (String | Symbol name, Type::t type) -> Scope
+    def with_rejoined_locals: (untyped) -> Rigor::Scope
     def with_ivar: (String | Symbol name, Type::t type) -> Scope
     def with_local_origin: (String | Symbol name, Symbol? cause) -> Scope
     def with_optimistic_local: (String | Symbol name, Symbol? cause, ?miss: Object?) -> Scope
@@ -299,6 +300,8 @@ module Rigor
     def inferred_param?: (String | Symbol name) -> bool
     def forget_match_globals: () -> Scope
     def untyped_match_globals: () -> Scope
+    # sig-gen gap: #1154 — the reader over the `@globals` ivar `initialize` assigns from a parameter reaches
+    # `untyped`, so the `bool` is hand-written.
     def match_globals_bound?: () -> bool
     def with_match_frame: (untyped body, ?untyped parameters) -> Scope
     # sig-gen gap: #1154 — the frame reader over an ivar assigned in `initialize` from a parameter reaches

data/sig/rigor.rbs

@@ -83,7 +83,6 @@ module Rigor
 
     class RunStats
       attr_reader wall_seconds: Float
-      attr_reader peak_rss_bytes: Integer?
       attr_reader target_files: Integer
       attr_reader rbs_classes_total: Integer
       attr_reader rbs_classes_project_sig: Integer
@@ -93,21 +92,25 @@ module Rigor
       attr_reader rbs_attribution_available: bool
 
       CACHED_SENTINEL: String
+      CURRENT_PROCESS_PEAK_RSS: ^() -> Integer?
 
+      # authored: #1529 memoised lazy read; its type enters only through the deliberate `peak_rss_probe:` initialize parameter.
+      def peak_rss_bytes: () -> Integer?
       def self.peak_rss_bytes: () -> Integer?
       def self.partition_classes: (class_decl_paths: Hash[String, String], signature_paths: Array[untyped]) -> [Integer, Integer]
       def self.attribution_available?: (class_decl_paths: Hash[String, String]) -> bool
 
       def initialize: (
         wall_seconds: Float,
-        peak_rss_bytes: Integer?,
         target_files: Integer,
         rbs_classes_total: Integer,
         rbs_classes_project_sig: Integer,
         rbs_classes_bundled: Integer,
         gem_walk_classes: Integer,
         gem_walk_gems: Integer,
-        ?rbs_attribution_available: bool
+        ?rbs_attribution_available: bool,
+        ?peak_rss_bytes: Integer?,
+        ?peak_rss_probe: ^() -> Integer?
       ) -> void
       def format: (untyped out, ?prefix: String) -> void
       def to_h: () -> Hash[Symbol, untyped]

data/skills/rigor-project-init/references/02-configure.md

@@ -97,8 +97,8 @@ test_paths:
   - spec
 
 exclude:
-  - vendor
-  - tmp
+  - "vendor/**"
+  - "tmp/**"
 
 plugins:
   - rigor-actionpack

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rigortype
 version: !ruby/object:Gem::Version
-  version: 0.4.2
+  version: 0.4.4
 platform: ruby
 authors:
 - Rigor contributors
@@ -321,6 +321,7 @@ files:
 - data/core_overlay/module.rbs
 - data/core_overlay/numeric.rbs
 - data/core_overlay/object_space.rbs
+- data/core_overlay/ostruct.rbs
 - data/core_overlay/pathname.rbs
 - data/core_overlay/proc.rbs
 - data/core_overlay/process.rbs
@@ -564,6 +565,7 @@ files:
 - lib/rigor/cli/explain_command.rb
 - lib/rigor/cli/fused_protection_renderer.rb
 - lib/rigor/cli/fused_protection_report.rb
+- lib/rigor/cli/lens_command.rb
 - lib/rigor/cli/lsp_command.rb
 - lib/rigor/cli/mcp_command.rb
 - lib/rigor/cli/measurement_integrity_warning.rb
@@ -756,6 +758,7 @@ files:
 - lib/rigor/inference/match_rebinding/self_calls.rb
 - lib/rigor/inference/method_dispatcher.rb
 - lib/rigor/inference/method_dispatcher/alias_strict_nominals.rb
+- lib/rigor/inference/method_dispatcher/argument_nodes.rb
 - lib/rigor/inference/method_dispatcher/arithmetic_sequence_elements.rb
 - lib/rigor/inference/method_dispatcher/array_to_h_folding.rb
 - lib/rigor/inference/method_dispatcher/block_folding.rb
@@ -777,6 +780,7 @@ files:
 - lib/rigor/inference/method_dispatcher/math_folding.rb
 - lib/rigor/inference/method_dispatcher/member_shape_projection.rb
 - lib/rigor/inference/method_dispatcher/method_folding.rb
+- lib/rigor/inference/method_dispatcher/optional_count.rb
 - lib/rigor/inference/method_dispatcher/overload_selector.rb
 - lib/rigor/inference/method_dispatcher/process_folding.rb
 - lib/rigor/inference/method_dispatcher/proven_overload.rb
@@ -795,6 +799,7 @@ files:
 - lib/rigor/inference/method_dispatcher/struct_folding.rb
 - lib/rigor/inference/method_dispatcher/struct_materialization.rb
 - lib/rigor/inference/method_dispatcher/time_folding.rb
+- lib/rigor/inference/method_dispatcher/unit_denominator_rational.rb
 - lib/rigor/inference/method_dispatcher/universal_object_dispatch.rb
 - lib/rigor/inference/method_dispatcher/uri_folding.rb
 - lib/rigor/inference/method_parameter_binder.rb
@@ -812,6 +817,7 @@ files:
 - lib/rigor/inference/pre_eval_constants.rb
 - lib/rigor/inference/precision_scanner.rb
 - lib/rigor/inference/project_method_ownership.rb
+- lib/rigor/inference/project_patched_definedness_guard.rb
 - lib/rigor/inference/project_patched_methods.rb
 - lib/rigor/inference/project_patched_scanner.rb
 - lib/rigor/inference/protection_scanner.rb
@@ -822,8 +828,10 @@ files:
 - lib/rigor/inference/refine_census.rb
 - lib/rigor/inference/refine_self.rb
 - lib/rigor/inference/refined_dispatch.rb
+- lib/rigor/inference/refined_dispatch/class_object.rb
 - lib/rigor/inference/refined_dispatch/own_method.rb
 - lib/rigor/inference/refinement_mutation.rb
+- lib/rigor/inference/reflective_ivar_write.rb
 - lib/rigor/inference/repeated_or_writes.rb
 - lib/rigor/inference/return_barrier.rb
 - lib/rigor/inference/rewrite_mutation.rb
@@ -835,6 +843,7 @@ files:
 - lib/rigor/inference/scope_indexer/member_layouts_collector.rb
 - lib/rigor/inference/scope_indexer/mixin_accumulator.rb
 - lib/rigor/inference/scope_indexer/superclasses_collector.rb
+- lib/rigor/inference/self_call_ivar_writes.rb
 - lib/rigor/inference/singleton_hook_decline.rb
 - lib/rigor/inference/singleton_object_constant.rb
 - lib/rigor/inference/statement_evaluator.rb
@@ -846,6 +855,7 @@ files:
 - lib/rigor/inference/synthetic_method_scanner.rb
 - lib/rigor/inference/unknown_store_widening.rb
 - lib/rigor/inference/unthreaded_rebinds.rb
+- lib/rigor/inference/untyped_rejoin.rb
 - lib/rigor/inference/version_guard.rb
 - lib/rigor/inference/void_origin.rb
 - lib/rigor/inference/void_tail_summary.rb
@@ -868,6 +878,16 @@ files:
 - lib/rigor/language_server/signature_help_provider.rb
 - lib/rigor/language_server/synchronized_writer.rb
 - lib/rigor/language_server/uri.rb
+- lib/rigor/lens.rb
+- lib/rigor/lens/anchor.rb
+- lib/rigor/lens/contract_reader.rb
+- lib/rigor/lens/document.rb
+- lib/rigor/lens/file_reader.rb
+- lib/rigor/lens/members.rb
+- lib/rigor/lens/parameters.rb
+- lib/rigor/lens/plugins.rb
+- lib/rigor/lens/run.rb
+- lib/rigor/lens/slot.rb
 - lib/rigor/mcp.rb
 - lib/rigor/mcp/loop.rb
 - lib/rigor/mcp/server.rb