rigortype 0.1.5 → 0.1.7

data/lib/rigor/analysis/check_rules.rb

@@ -228,10 +228,26 @@ module Rigor
       def ivar_mismatch_diagnostics_for(path, class_name, ivar_name, writes)
         return [] if writes.size < 2
 
-        first_class = ivar_class_for(writes.first[:type])
+        # Skip past leading `NilClass` writes when establishing
+        # the canonical type. The common nullable-slot idiom
+        # (`@x = nil` placeholder in `initialize` / a default
+        # state slot, then `@x = :foo` on first concrete state)
+        # would otherwise fire a false positive on every
+        # concrete write because `first_class` was `NilClass`
+        # and every subsequent `Symbol` / `String` / `Hash`
+        # write triggered the divergence rule. The first
+        # concrete (non-nil) write is the canonical type;
+        # additional `NilClass` writes are still tolerated
+        # downstream by the existing `other_class == "NilClass"`
+        # check (the nullable-slot resets to nil between work).
+        canonical = writes.find { |w| ivar_class_for(w[:type]) != "NilClass" }
+        return [] if canonical.nil?
+
+        first_class = ivar_class_for(canonical[:type])
         return [] if first_class.nil?
 
-        writes[1..].filter_map do |write|
+        canonical_index = writes.index(canonical)
+        writes[(canonical_index + 1)..].filter_map do |write|
           other_class = ivar_class_for(write[:type])
           next nil if other_class.nil? || other_class == "NilClass" || other_class == first_class
 
@@ -358,9 +374,27 @@ module Rigor
           method_def = lookup_method(receiver_type, class_name, call_node.name, scope)
           return nil if method_def
 
+          # Module-mixin fallback (mirror of
+          # `MethodDispatcher#user_class_fallback_receiver`'s module
+          # path): an instance method on a module-mixin like
+          # `PP::ObjectMixin` observes Kernel / Object methods
+          # through every concrete includer's ancestor chain, so an
+          # unresolved `self.inspect` / `self.respond_to?` /
+          # `self.class` MUST NOT fire `undefined-method`. Retry
+          # against Object before the rule fires.
+          return nil if module_mixin_receiver?(receiver_type, scope) &&
+                        lookup_method(receiver_type, "Object", call_node.name, scope)
+
           build_undefined_method_diagnostic(path, call_node, receiver_type)
         end
 
+        def module_mixin_receiver?(receiver_type, scope)
+          return false unless receiver_type.is_a?(Type::Nominal)
+          return false if scope.environment.nil?
+
+          scope.environment.rbs_module?(receiver_type.class_name)
+        end
+
         # Returns a qualified class name for the in-scope check.
         # Nominal / Singleton carry a single-class identity
         # directly. Constant projects to its value's class.
@@ -944,8 +978,18 @@ module Rigor
         # / Constant / Tuple / HashShape; the wrapper exists so
         # the ivar rule can extend the envelope (or apply
         # different filters) without disturbing the call rules.
+        #
+        # `TrueClass` / `FalseClass` are both normalised to
+        # `"bool"` here so the common boolean-flag idiom
+        # (`@loaded = false` in `initialize` then `@loaded = true`
+        # on first work) doesn't fire the mismatch rule. A real
+        # `bool → String` drift still trips because the second
+        # write's `ivar_class_for` returns `"String"`.
         def ivar_class_for(type)
-          concrete_class_name(type)
+          name = concrete_class_name(type)
+          return "bool" if %w[TrueClass FalseClass].include?(name)
+
+          name
         end
 
         def build_always_truthy_condition_diagnostic(path, predicate_node, polarity)
@@ -1032,8 +1076,29 @@ module Rigor
         #   (no splat / kw / block-pass / forwarded).
         # - Per-argument: skip when EITHER side is `Dynamic`
         #   (the call cannot be statically refuted).
+        # Ruby's universal-equality methods accept any object
+        # per the `Object#==(other) → bool` /
+        # `Object#eql?(other) → bool` contract. Even when a
+        # subclass overrides `==` to compare specific shapes
+        # (URI::Generic#==(URI::Generic), Time#==(Time), …),
+        # the runtime convention is to RETURN false for
+        # type-mismatched arguments rather than raise. RBS sigs
+        # that declare a tight parameter type therefore over-
+        # specify; checking arguments against them produces
+        # spurious mismatches such as
+        #   `URI::Generic#==(URI::Generic)`
+        #   called with `URI::HTTP | nil`
+        # tdiary-core's `config_uri == referer_uri` (where
+        # `referer_uri` is `URI.parse(...) if condition`, hence
+        # union-with-nil) is the canonical case. Skip arg
+        # checking on these methods entirely; the call is
+        # well-formed by Ruby's contract.
+        UNIVERSAL_EQUALITY_METHODS = %i[== != eql? equal? <=>].to_set.freeze
+        private_constant :UNIVERSAL_EQUALITY_METHODS
+
         def argument_type_diagnostic(path, call_node, scope_index)
           return nil if call_node.receiver.nil?
+          return nil if UNIVERSAL_EQUALITY_METHODS.include?(call_node.name)
           return nil unless plain_positional_call?(call_node)
 
           scope = scope_index[call_node]

data/lib/rigor/analysis/dependency_source_inference/index.rb

@@ -54,7 +54,7 @@ module Rigor
         )
           @resolved_gems = resolved_gems.freeze
           @unresolvable = unresolvable.freeze
-          @method_catalog = method_catalog.freeze
+          @method_catalog = normalize_catalog(method_catalog).freeze
           @budget_exceeded = budget_exceeded.freeze
           @class_to_gem = class_to_gem.freeze
           @budget_overrun_strategy = budget_overrun_strategy
@@ -62,6 +62,19 @@ module Rigor
           freeze
         end
 
+        # Accepts both the post-heuristic `CatalogEntry` shape
+        # (the Walker's current output) and the legacy bare-Symbol
+        # `:instance` / `:singleton` shape (older tests + earlier
+        # in-tree callers). Symbol values are wrapped into
+        # `CatalogEntry(kind: value, return_type: nil)` so the
+        # downstream dispatcher always sees a single shape.
+        def normalize_catalog(catalog)
+          catalog.transform_values do |value|
+            value.is_a?(Symbol) ? Walker::CatalogEntry.new(kind: value) : value
+          end
+        end
+        private :normalize_catalog
+
         # @return [String, nil] the gem that owns `class_name`
         #   (first-write-wins); `nil` when the class isn't in
         #   any opt-in gem's catalog.

data/lib/rigor/analysis/dependency_source_inference/return_type_heuristic.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require "prism"
+
+require_relative "../../type"
+
+module Rigor
+  module Analysis
+    module DependencySourceInference
+      # Walker enhancement (ADR-10 § "Open questions"): pulls a
+      # **heuristic** return type out of a method body's tail
+      # expression. The heuristic is intentionally narrow — only
+      # the trivially-decidable shapes contribute. Everything
+      # else returns `nil`, which the dispatcher consumes as
+      # "fall back to `Dynamic[top]`" (the pre-enhancement
+      # behaviour).
+      #
+      # The contract is a strict floor:
+      #
+      # - Last statement is a literal scalar (Integer / Float /
+      #   Symbol / true / false / nil) → `Constant<value>`.
+      # - Last statement is a String literal → `Nominal[String]`
+      #   (NOT `Constant<"x">`; a String literal is mutable under
+      #   `# frozen_string_literal: false`, so the analyzer cannot
+      #   claim object identity).
+      # - Last statement is an Array / Hash literal →
+      #   `Nominal[Array]` / `Nominal[Hash]` (element-type
+      #   inference stays deferred — too expensive for the
+      #   heuristic tier).
+      # - Last statement is `self` → `nil` (the caller's receiver
+      #   nominal would be more accurate but the walker doesn't
+      #   carry the receiver context; deferred).
+      # - Anything else → `nil`.
+      #
+      # The dispatcher wraps the returned type in `Dynamic[T]`
+      # before returning to the user per ADR-10's `Dynamic`-origin
+      # contract. The wrapping is the dispatcher's responsibility,
+      # not the heuristic's.
+      module ReturnTypeHeuristic
+        module_function
+
+        # @param def_node [Prism::DefNode]
+        # @return [Rigor::Type, nil] heuristic return type, or
+        #   `nil` when the body's tail expression doesn't match
+        #   any of the recognised shapes.
+        def extract(def_node)
+          body = def_node.body
+          return nil if body.nil?
+
+          tail = tail_expression(body)
+          literal_return_type(tail)
+        end
+
+        # Extracts the last evaluated expression of the method
+        # body. A `Prism::DefNode`'s body is either a
+        # `StatementsNode` (multi-statement body) or a single
+        # expression node directly. We dig past `BeginNode` /
+        # rescue wrappers to the protected body's tail.
+        def tail_expression(node)
+          case node
+          when Prism::StatementsNode
+            tail_expression(node.body.last) unless node.body.empty?
+          when Prism::BeginNode
+            tail_expression(node.statements) if node.statements
+          when nil
+            nil
+          else
+            node
+          end
+        end
+        private_class_method :tail_expression
+
+        # The per-shape heuristic. Per the module docstring,
+        # immutable scalar literals fold to `Constant<value>`;
+        # mutable container literals (String, Array, Hash) fold
+        # to the appropriate Nominal; everything else returns
+        # nil.
+        def literal_return_type(node)
+          case node
+          when Prism::IntegerNode, Prism::FloatNode then Type::Combinator.constant_of(node.value)
+          when Prism::SymbolNode then symbol_constant(node)
+          when Prism::TrueNode then Type::Combinator.constant_of(true)
+          when Prism::FalseNode then Type::Combinator.constant_of(false)
+          when Prism::NilNode then Type::Combinator.constant_of(nil)
+          when Prism::StringNode then Type::Combinator.nominal_of("String")
+          when Prism::ArrayNode then Type::Combinator.nominal_of("Array")
+          when Prism::HashNode then Type::Combinator.nominal_of("Hash")
+          end
+        end
+        private_class_method :literal_return_type
+
+        # `Prism::SymbolNode#value` returns the Symbol's name as
+        # a String. We `.to_sym` it for the Constant carrier so
+        # `:foo` is `Constant<:foo>`, not `Constant<"foo">`.
+        def symbol_constant(node)
+          value = node.value
+          return nil if value.nil?
+
+          Type::Combinator.constant_of(value.to_sym)
+        end
+        private_class_method :symbol_constant
+      end
+    end
+  end
+end

data/lib/rigor/analysis/dependency_source_inference/walker.rb

@@ -2,23 +2,26 @@
 
 require "prism"
 
+require_relative "return_type_heuristic"
+
 module Rigor
   module Analysis
     module DependencySourceInference
       # Walks a resolved gem's `roots:` and collects the
-      # `(class_name, method_name) → :instance | :singleton`
-      # method catalog. The walker is the source of facts the
-      # dispatcher tier (slice 2b-ii) consults to recognise a
+      # `(class_name, method_name) → CatalogEntry(kind,
+      # return_type)` method catalog. The walker is the source
+      # of facts the dispatcher tier consults to recognise a
       # method as defined by an opt-in gem and contribute a
-      # `Type::Dynamic` return at the call site.
+      # `Type::Dynamic`-wrapped return at the call site.
       #
-      # Slice 2b-i intentionally collects only the catalog, not
-      # the inferred return type. The dispatcher tier returns
-      # `Dynamic[top]` on a hit until slice 2b-ii wires return-
-      # type inference; the visible payoff today is removing the
-      # `call.undefined-method` diagnostic for opt-in gem methods
-      # at receivers Rigor knows by `Nominal[T]` (typically
-      # because the user authored an RBS skeleton).
+      # The dispatcher tier wraps every walker-contributed return
+      # in `Dynamic[T]` per ADR-10's gem-boundary contract. When
+      # the heuristic ({ReturnTypeHeuristic}) recognises the
+      # method body's tail expression, the dispatcher uses the
+      # heuristic's static facet; otherwise it falls back to
+      # `Dynamic[top]` (the pre-heuristic behaviour). The
+      # heuristic is intentionally narrow — only literal-tail
+      # method bodies fold; everything else degrades silently.
       #
       # Hard exclusions are NOT user-configurable, per ADR-10
       # § "Hard exclusions": top-level `spec/`, `test/`, `bin/`,
@@ -45,6 +48,19 @@ module Rigor
           def truncated? = truncated
         end
 
+        # Per-method catalog entry. `kind` is `:instance` or
+        # `:singleton`; `return_type` is the
+        # {ReturnTypeHeuristic}-extracted static facet (a
+        # `Rigor::Type::*`) or `nil` when the heuristic declined.
+        # The dispatcher wraps a non-nil `return_type` in
+        # `Dynamic[T]`; a `nil` `return_type` falls back to
+        # `Dynamic[top]`.
+        class CatalogEntry < Data.define(:kind, :return_type)
+          def initialize(kind:, return_type: nil)
+            super
+          end
+        end
+
         # Sentinel for "no cap" — used by callers that don't
         # care about the budget (specs, tooling). Production
         # code MUST pass an integer.
@@ -175,7 +191,11 @@ module Rigor
 
           class_name = qualified_prefix.join("::")
           kind = node.receiver.is_a?(Prism::SelfNode) || in_singleton_class ? :singleton : :instance
-          accumulator[[class_name, node.name]] ||= kind
+          key = [class_name, node.name]
+          return if accumulator.key?(key) # first walk wins
+
+          return_type = ReturnTypeHeuristic.extract(node)
+          accumulator[key] = CatalogEntry.new(kind: kind, return_type: return_type)
         end
 
         # Resolves a `Prism::ConstantPathNode` /

data/lib/rigor/analysis/project_scan.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Rigor
+  module Analysis
+    # Frozen snapshot of the project-wide state {Runner} consumes
+    # before per-file analysis fires: the loaded plugin registry
+    # (with `#prepare` already invoked), the dependency-source
+    # index, the synthetic-method and project-patched indexes
+    # produced by the pre-pass scanners, and the diagnostics
+    # those passes emitted.
+    #
+    # Owners (`Rigor::LanguageServer::ProjectContext`, future
+    # editor / sig-gen integrations) build a ProjectScan once
+    # per project-state generation via
+    # `Runner#prepare_project_scan` and pass it to
+    # `Runner.new(prebuilt: ...)` so per-buffer publishes skip
+    # the scanner walks and `#prepare` re-runs. When watched
+    # project files change, the owner discards the ProjectScan
+    # and a fresh one builds on next read.
+    #
+    # Editor mode v1 contract reminder: scanners observe the
+    # bytes that were on disk at scan time, NOT the in-flight
+    # buffer. Edits to a file that itself declares synthetic
+    # methods (or `pre_eval:`-listed patches) are NOT visible
+    # until the owner invalidates the scan — typically via
+    # `workspace/didChangeWatchedFiles`. This is the same
+    # trade-off the LSP made when slice 7 cached only the
+    # `Environment`; extending the cache to the pre-pass
+    # outputs preserves the contract.
+    ProjectScan = Data.define(
+      :plugin_registry,
+      :dependency_source_index,
+      :synthetic_method_index,
+      :project_patched_methods,
+      :plugin_prepare_diagnostics,
+      :pre_eval_diagnostics
+    )
+  end
+end