rigortype 0.3.8 → 0.3.9

data/lib/rigor/environment.rb

@@ -13,6 +13,7 @@ require_relative "environment/constant_type_cache_holder"
 require_relative "environment/missing_gem_constant_index"
 require_relative "environment/bundle_sig_discovery"
 require_relative "environment/lockfile_resolver"
+require_relative "environment/installed_gem_set"
 require_relative "environment/rbs_collection_discovery"
 require_relative "plugin/isolation"
 require_relative "environment/rbs_coverage_report"
@@ -48,16 +49,15 @@ module Rigor
                 :reporters, :name_scope,
                 :synthetic_method_index, :project_patched_methods
 
-    # @param class_registry [Rigor::Environment::ClassRegistry]
-    # @param rbs_loader [Rigor::Environment::RbsLoader, nil] when nil the environment is "RBS-blind"; useful
+    # @param rbs_loader — when nil the environment is "RBS-blind"; useful
     #   in tests that want to assert how the engine behaves without RBS data. The default Environment wires
     #   the shared core loader, which is itself lazy: requesting an environment instance does NOT load RBS
     #   until a method or class query actually consults the loader.
-    # @param plugin_registry [Rigor::Plugin::Registry, nil] v0.1.1 Track 2 slice 7. The per-run plugin
+    # @param plugin_registry — v0.1.1 Track 2 slice 7. The per-run plugin
     #   registry the inference engine consults at call sites for plugin `dynamic_return` rules. When nil
     #   (the default), no plugin-level return-type contribution participates — useful for tests, the
     #   `Environment.default` facade, and analyses that don't load plugins.
-    # @param dependency_source_index [Rigor::Analysis::DependencySourceInference::Index, nil] ADR-10 slice
+    # @param dependency_source_index — ADR-10 slice
     #   2b-ii. The per-run index of opt-in gem sources the dispatcher consults BELOW RBS dispatch. When nil
     #   (the default), no dep-source contribution participates and the dispatcher tier is a no-op.
     def initialize(class_registry: ClassRegistry.default, rbs_loader: nil, # rubocop:disable Metrics/ParameterLists
@@ -151,7 +151,7 @@ module Rigor
     # defect. First-write-wins on the slot means a run whose overlay AND scan both raise reports the
     # overlay — the actionable one, since the plugin is what a user can remove.
     #
-    # @return [Rigor::Inference::HktRegistry] the registry the RBS scan is layered on top of.
+    # @return the registry the RBS scan is layered on top of.
     def pre_scan_hkt_registry
       return @hkt_registry_base unless @plugin_registry.respond_to?(:hkt_overlay_registry)
 
@@ -171,8 +171,6 @@ module Rigor
     # worker (the coordinator never analyses a file under the pool, so the drain is how its snapshot learns
     # the outcome: the #696 lesson), and from a resolved environment when the analyze set is empty — so the
     # row never depends on which files happened to be analysed.
-    #
-    # @return [Array(String, String, String, Symbol), Array(String, String, nil, Symbol), nil]
     def hkt_scan_failure
       @hkt_scan_failure.value
     end
@@ -255,18 +253,17 @@ module Rigor
       # Builds an Environment that consults the project's local signatures and any opt-in stdlib libraries on
       # top of RBS core.
       #
-      # @param root [String, Pathname] project root used to auto-detect the default signature path. Defaults
+      # @param root — project root used to auto-detect the default signature path. Defaults
       #   to the current working directory.
-      # @param libraries [Array<String, Symbol>] additional stdlib libraries to load on top of
+      # @param libraries — additional stdlib libraries to load on top of
       #   {DEFAULT_LIBRARIES}. The final list is the union of the two, de-duplicated while preserving order.
       #   Pass an empty array (the default) to load only the defaults.
-      # @param signature_paths [Array<String, Pathname>, nil] explicit list of `sig/`-style directories. When
+      # @param signature_paths — explicit list of `sig/`-style directories. When
       #   `nil` (the default), the canonical project layout `<root>/sig` is used if it exists, otherwise no
       #   signature path is loaded.
-      # @param cache_store [Rigor::Cache::Store, nil] persistent cache threaded into the underlying
+      # @param cache_store — persistent cache threaded into the underlying
       #   {Environment::RbsLoader} so constant lookups (and, in later v0.0.9 slices, other reflection
       #   artefacts) consult the cache. Pass `nil` (the default) to skip caching for this environment.
-      # @return [Rigor::Environment]
       # rubocop:disable-next Metrics/MethodLength, Metrics/ParameterLists
       def for_project(root: Dir.pwd, libraries: [], signature_paths: nil, cache_store: nil,
                       plugin_registry: nil, dependency_source_index: nil,
@@ -336,7 +333,7 @@ module Rigor
         missing_gems, overlay_paths = missing_gems_and_overlay_paths(
           locked: locked, default_libraries: merged_libraries, bundle_sig_paths: gem_sig_paths,
           rbs_collection_paths: collection_paths, plugin_registry: plugin_registry,
-          signature_paths: resolved_paths
+          signature_paths: resolved_paths, bundle_root: bundle_root
         )
         loader_signature_paths = resolved_paths + plugin_sig_paths + gem_sig_paths +
                                  collection_paths + overlay_paths
@@ -361,6 +358,13 @@ module Rigor
           # the bundle walk and `rbs collection install` all stay authoritative.
           deferred_signature_paths: plugin_sig_paths
         )
+        # Issue #824 / ADR-32 WD13 — one `:info` per inline member the loader stood down against the
+        # project's own `sig/`. Recorded HERE because this is where the reporter is: the run's
+        # `source_rbs_synthesis` stream already carries WD12's "parsed but not honoured" rows, drains out of
+        # pool workers, and is regenerated (never cached) on every run, so the member-level stand-down needs
+        # no plumbing of its own. Costs nothing for a project with no inline RBS: the loader's reader
+        # short-circuits on an empty `virtual_rbs`.
+        record_inline_member_standdowns(loader, source_rbs_synthesis_reporter, root)
         # ADR-20 slice 2c + 2e — seed hkt_registry with the bundled builtins. The Environment's
         # `#hkt_registry` getter then LAZILY merges in the RBS env scan on first call so fast paths that
         # don't consult HKT (e.g. `rigor check --cache-stats --no-stats`) don't pay the eager env-build cost
@@ -412,13 +416,13 @@ module Rigor
       # and consumed twice: as `[gem_name, version]` pairs for the ADR-82 WD9 constant-ownership index, and
       # as the eligible-gem set for the ADR-72 overlay resolution. Returns `[pairs, overlay_paths]`.
       def missing_gems_and_overlay_paths(locked:, default_libraries:, bundle_sig_paths:,
-                                         rbs_collection_paths:, plugin_registry:, signature_paths: [])
-        return [[], []] if locked.empty?
+                                         rbs_collection_paths:, plugin_registry:, signature_paths: [],
+                                         bundle_root: nil)
+        if locked.empty?
+          return unlocked_missing_gems(default_libraries, bundle_sig_paths, rbs_collection_paths, bundle_root)
+        end
 
-        rows = RbsCoverageReport.classify(
-          locked_gems: locked, default_libraries: default_libraries,
-          bundle_sig_paths: bundle_sig_paths, rbs_collection_paths: rbs_collection_paths
-        ).select { |row| row.source == :missing }
+        rows = missing_rows(locked, default_libraries, bundle_sig_paths, rbs_collection_paths)
         overlays = gem_overlay_paths(
           missing_gem_names: rows.map(&:gem_name), plugin_registry: plugin_registry,
           signature_paths: signature_paths
@@ -426,6 +430,27 @@ module Rigor
         [rows.map { |row| [row.gem_name, row.version] }, overlays]
       end
 
+      # Issue #530 — a project with no `Gemfile.lock` still has gems on disk, and before this it handed the
+      # ADR-82 WD9 index nothing, so every constant reaching into an RBS-less gem kept the generic cause and
+      # the whole boundary reported as `engine_gap` rather than `add_rbs`. The installed set stands in for
+      # the locked one ({InstalledGemSet} says why that stays honest), and only for the provenance index:
+      # the second element is always empty because the ADR-72 overlays change what type-checks and so remain
+      # gated on the project's own declaration.
+      def unlocked_missing_gems(default_libraries, bundle_sig_paths, rbs_collection_paths, bundle_root)
+        installed = InstalledGemSet.gems(bundle_path: bundle_root)
+        return [[], []] if installed.empty?
+
+        rows = missing_rows(installed, default_libraries, bundle_sig_paths, rbs_collection_paths)
+        [rows.map { |row| [row.gem_name, row.version] }, []]
+      end
+
+      def missing_rows(gems, default_libraries, bundle_sig_paths, rbs_collection_paths)
+        RbsCoverageReport.classify(
+          locked_gems: gems, default_libraries: default_libraries,
+          bundle_sig_paths: bundle_sig_paths, rbs_collection_paths: rbs_collection_paths
+        ).select { |row| row.source == :missing }
+      end
+
       # ADR-72 — resolve the bundled RBS overlay directories to load for this project. A gem is eligible when
       # it is classified `:missing` (see {missing_rbs_gem_rows}) and its conflicting opt-in plugin twin (if
       # any) is NOT already reachable. Returns `[Pathname]`, deterministically ordered, or `[]` when no
@@ -540,6 +565,54 @@ module Rigor
         reporter&.record(plugin_id: plugin.manifest.id, path: path, message: message.to_s, kind: kind)
       end
 
+      # ADR-32 WD13 — turn each {Environment::RbsLoader#inline_member_standdowns} record into a WD12
+      # `:not_honoured` entry, so the run's `plugin.rbs-inline.source-rbs-annotation-not-honoured` row names
+      # BOTH sources and which one won. WD12's rule is what makes this necessary rather than optional: an
+      # annotation Rigor parses and does not honour is reported, never swallowed — and a silent per-member
+      # strip is exactly the shape that rule forbids.
+      #
+      # The row is positioned at the annotated `.rb` (line 1, as every entry on this stream is): the member's
+      # own position lives in the synthesized RBS buffer, which describes a document nobody has, and the
+      # ADR-54 environment cache drops positions anyway, so a line read off it would differ warm and cold.
+      def record_inline_member_standdowns(loader, reporter, root)
+        return if reporter.nil?
+
+        loader.inline_member_standdowns.each do |class_name, method_name, kind, signature_path, virtual_name|
+          plugin_id, path = split_virtual_source_name(virtual_name)
+          next if path.nil?
+
+          reporter.record(
+            plugin_id: plugin_id, path: path, kind: :not_honoured,
+            message: inline_member_standdown_message(class_name, method_name, kind, signature_path, root)
+          )
+        end
+      end
+
+      # Splits a virtual buffer name back into the pair {.collect_virtual_rbs} composed it from
+      # (`virtual:<plugin id>:<source path>`). Limited to three fields so a path carrying a colon survives.
+      # Returns `[nil, nil]` for a name in any other shape — a synthesizer channel this method does not own.
+      def split_virtual_source_name(virtual_name)
+        prefix, plugin_id, path = virtual_name.to_s.split(":", 3)
+        return [nil, nil] unless prefix == "virtual" && plugin_id && !plugin_id.empty? && path && !path.empty?
+
+        [plugin_id, path]
+      end
+
+      def inline_member_standdown_message(class_name, method_name, kind, signature_path, root)
+        separator = kind == :singleton ? "." : "#"
+        "`#{class_name}#{separator}#{method_name}` is also declared in " \
+          "`#{path_relative_to(signature_path, root)}`, and an explicit `.rbs` declaration wins over an " \
+          "inline annotation for the same member, so the inline signature was dropped. Left to collide the " \
+          "two would fail the class's definition build, and every call on it — real methods and typos " \
+          "alike — would read `Dynamic[top]`. Remove one of the two declarations to make the inline " \
+          "annotation bind."
+      end
+
+      def path_relative_to(path, root)
+        prefix = "#{root}#{File::SEPARATOR}"
+        path.to_s.start_with?(prefix) ? path.to_s.delete_prefix(prefix) : path.to_s
+      end
+
       SYNTHESIZER_CACHE_PRODUCER_ID = "plugin.source_rbs_synthesizer"
       private_constant :SYNTHESIZER_CACHE_PRODUCER_ID
 
@@ -653,6 +726,15 @@ module Rigor
       rbs_loader.rbs_module?(name)
     end
 
+    # Issue #915 — the module names RBS puts in `name`'s SINGLETON ancestry, the declaration-side twin of
+    # `Scope#singleton_extends_of`. `Inference::Narrowing` reads it the same one-directional way: presence
+    # withholds a `Bot`, absence asserts nothing (a class the environment does not know answers `[]`).
+    def singleton_extended_modules(name)
+      return [] unless rbs_loader
+
+      rbs_loader.singleton_extended_module_names(normalize_class_name(name))
+    end
+
     # Compares two class/module names using analyzer-owned class data. Returns `:equal`, `:subclass`,
     # `:superclass`, `:disjoint`, or `:unknown`. The static registry handles built-ins cheaply; the RBS
     # loader handles project/stdlib classes without relying on host Ruby constants being loaded.
@@ -677,8 +759,11 @@ module Rigor
       rbs_loader.class_known?(name)
     end
 
+    # Allocates only when there is a prefix to strip: `String#delete_prefix` copies unconditionally, and
+    # this runs once per class-registry / hierarchy probe (~320k times on the lib self-check).
     def normalize_class_name(name)
-      name.to_s.delete_prefix("::")
+      name = name.to_s
+      name.start_with?("::") ? name.delete_prefix("::") : name
     end
 
     # ADR-13 slice 3b — composes the per-run plugin-supplied {Rigor::TypeNode::ResolverChain} into a single

data/lib/rigor/flow_contribution/merger.rb

@@ -53,8 +53,6 @@ module Rigor
 
       module_function
 
-      # @param contributions [Array<FlowContribution>]
-      # @return [MergeResult]
       def merge(contributions)
         contributions = Array(contributions)
         return MergeResult.new if contributions.empty?

data/lib/rigor/flow_contribution.rb

@@ -49,24 +49,24 @@ module Rigor
 
     attr_reader(*SLOT_NAMES, :provenance)
 
-    # @param return_type [Object, nil] normal-edge return type. Use `nil` when the contribution does not
+    # @param return_type — normal-edge return type. Use `nil` when the contribution does not
     #   refine the return type selected from the RBS contract.
-    # @param truthy_facts [Array, nil] facts that hold only on the truthy control-flow edge. Edge-local: a
+    # @param truthy_facts — facts that hold only on the truthy control-flow edge. Edge-local: a
     #   truthy-edge fact does NOT imply its falsey-edge complement (ADR-2 § "Plugin Contribution Merging").
-    # @param falsey_facts [Array, nil] dual of `truthy_facts`.
-    # @param post_return_facts [Array, nil] facts that hold after the call returns normally on every edge —
+    # @param falsey_facts — dual of `truthy_facts`.
+    # @param post_return_facts — facts that hold after the call returns normally on every edge —
     #   the carrier for assertion-style contributions.
-    # @param mutations [Array, nil] receiver and argument mutation effects.
-    # @param invalidations [Array, nil] targeted fact invalidations beyond what mutation effects already
+    # @param mutations — receiver and argument mutation effects.
+    # @param invalidations — targeted fact invalidations beyond what mutation effects already
     #   imply.
-    # @param exceptional [Object, nil] non-returning, raising, or unreachable effect.
-    # @param role_conformance [Array, nil] capability-role conformance facts the contribution provides.
-    # @param effects [Rigor::Effects::LabelSet, nil] ADR-103 WD5 — the effect labels this call edge
+    # @param exceptional — non-returning, raising, or unreachable effect.
+    # @param role_conformance — capability-role conformance facts the contribution provides.
+    # @param effects — ADR-103 WD5 — the effect labels this call edge
     #   attributes to its callee, as an upper bound. `nil` means "says nothing about effects", which is
     #   NOT the same as the empty set (which asserts the call performs none). Merged by union, the
     #   conservative direction: two sources that each name part of a call's footprint together name
     #   more of it, and neither can shrink the other's claim.
-    # @param provenance [Provenance] source-family, plugin-id, node, and cache-descriptor metadata. Defaults
+    # @param provenance — source-family, plugin-id, node, and cache-descriptor metadata. Defaults
     #   to `Provenance.builtin`.
     # rubocop:disable Metrics/ParameterLists
     def initialize(return_type: nil, truthy_facts: nil, falsey_facts: nil,
@@ -87,7 +87,7 @@ module Rigor
       freeze
     end
 
-    # @return [Boolean] true when every content slot is unset (nil or an empty collection). Provenance does
+    # @return true when every content slot is unset (nil or an empty collection). Provenance does
     #   not count toward emptiness — an empty bundle still carries source attribution.
     def empty?
       SLOT_NAMES.all? { |slot| slot_empty?(slot, public_send(slot)) }
@@ -116,8 +116,6 @@ module Rigor
     # | exceptional         | exceptional   | exception           | :raise                  |
     # | role_conformance    | normal        | role                | (per-role target)       |
     # | effects             | normal        | effects             | :effects                |
-    #
-    # @return [Array<Element>]
     def to_element_list # rubocop:disable Metrics/AbcSize
       elements = []
       elements << element_for(:return, :normal, :return_type, return_type) unless return_type.nil?

data/lib/rigor/inference/acceptance.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "../type"
+require_relative "range_constant"
 
 module Rigor
   module Inference
@@ -27,10 +28,7 @@ module Rigor
     module Acceptance
       module_function
 
-      # @param self_type [Rigor::Type]
-      # @param other_type [Rigor::Type]
-      # @param mode [Symbol] `:gradual` (default) or `:strict`.
-      # @return [Rigor::Type::AcceptsResult]
+      # @param mode — `:gradual` (default) or `:strict`.
       def accepts(self_type, other_type, mode: :gradual)
         raise ArgumentError, "Acceptance mode #{mode.inspect} is not implemented yet" unless mode == :gradual
 
@@ -63,6 +61,7 @@ module Rigor
         Type::Nominal => :accepts_nominal,
         Type::Constant => :accepts_constant,
         Type::IntegerRange => :accepts_integer_range,
+        Type::FloatRange => :accepts_float_range,
         Type::Difference => :accepts_difference,
         Type::Refined => :accepts_refined,
         Type::Intersection => :accepts_intersection,
@@ -201,7 +200,8 @@ module Rigor
         #   {#accepts_nominal_args});
         # - Constant[v] when v.is_a?(klass(C)). The type_args of self are ignored here because a Constant
         #   carries a concrete value, not a generic instantiation, and the analyzer has no way to refute the
-        #   args from a literal alone.
+        #   args from a literal alone. A Range value is the one exception — see
+        #   {#accepts_range_constant_type_arg}.
         # - Tuple[*] when self is the Array (or a supertype) family. The Tuple is projected to
         #   `Nominal[Array, [union(elements)]]` so the existing generic-arg machinery handles it.
         # - HashShape{*} when self is the Hash (or a supertype) family, projected to
@@ -215,6 +215,7 @@ module Rigor
           when Type::Singleton then accepts_nominal_from_singleton(self_type, other_type, mode)
           when Type::StructClass, Type::DataClass then accepts_nominal_from_class_factory(self_type, other_type, mode)
           when Type::IntegerRange then accepts_nominal_from_integer_range(self_type, other_type, mode)
+          when Type::FloatRange then accepts_nominal_from_float_range(self_type, other_type, mode)
           else accepts_nominal_from_shape(self_type, other_type, mode)
           end
         end
@@ -311,6 +312,32 @@ module Rigor
           end
         end
 
+        # ADR-109 WD4 — the Float twin of the IntegerRange rule: `Nominal[Float]` and everything Float
+        # is-a accept any `FloatRange`; nothing else does.
+        FLOAT_NOMINAL_ANCESTORS = %w[Float Numeric Comparable Object BasicObject].freeze
+        private_constant :FLOAT_NOMINAL_ANCESTORS
+
+        def accepts_nominal_from_float_range(self_type, _other_type, mode)
+          unless self_type.type_args.empty?
+            return Type::AcceptsResult.no(
+              mode: mode,
+              reasons: "Nominal[#{self_type.class_name}] with type args rejects FloatRange"
+            )
+          end
+
+          if FLOAT_NOMINAL_ANCESTORS.include?(self_type.class_name)
+            Type::AcceptsResult.yes(
+              mode: mode,
+              reasons: "FloatRange is-a #{self_type.class_name}"
+            )
+          else
+            Type::AcceptsResult.no(
+              mode: mode,
+              reasons: "Nominal[#{self_type.class_name}] rejects FloatRange"
+            )
+          end
+        end
+
         # v0.0.2 — meta-type rule. A `Singleton[T]` is the class object for `T`, so it is an instance of
         # `Class` (when `T` is a class) and always an instance of `Module`. Without this rule a method whose
         # parameter is typed `Class | Module` would reject every `is_a?(SomeClass)` call and similar
@@ -492,7 +519,7 @@ module Rigor
 
         def accepts_nominal_from_constant(self_type, constant, mode)
           ruby_class = resolve_class(self_type.class_name)
-          return constant_is_a_result(ruby_class, constant, self_type, mode) if ruby_class
+          return accepts_loaded_class_from_constant(ruby_class, constant, self_type, mode) if ruby_class
 
           # The host process may not have required the constant's declared self_type (e.g. `BigDecimal`
           # since Ruby 3.4 is no longer a default gem). Fall back to inspecting the value's own class
@@ -527,6 +554,13 @@ module Rigor
           end
         end
 
+        def accepts_loaded_class_from_constant(ruby_class, constant, self_type, mode)
+          result = constant_is_a_result(ruby_class, constant, self_type, mode)
+          return result unless result.yes?
+
+          accepts_range_constant_type_arg(self_type, constant, mode) || result
+        end
+
         def constant_is_a_result(ruby_class, constant, self_type, mode)
           if constant.value.is_a?(ruby_class)
             Type::AcceptsResult.yes(mode: mode, reasons: "Constant value is_a?(#{self_type.class_name})")
@@ -538,10 +572,53 @@ module Rigor
           end
         end
 
+        # Issue #833 — the single exception to "the type_args of self are ignored for a Constant".
+        #
+        # A `Constant<Range>` is the one literal that does pin a generic instantiation: the engine
+        # builds it only when both endpoints are static, so `Range[T]` CAN be refuted from the literal.
+        # Without this, `Nominal[Range, [Integer]]` accepted `0.0...1.0` and `OverloadSelector` pass 1
+        # pinned whichever `Range[…]` arm came first in declaration order — for `Kernel#rand` that is
+        # `(::Range[Integer]) -> Integer?`, ahead of every Float arm.
+        #
+        # Returns nil — "no opinion, keep the class-level answer" — outside the envelope: a raw `Range`
+        # or any other arity of type_args, and a range the shared reader cannot read endpoints from.
+        # A missing endpoint contributes nothing, because a beginless or endless literal inhabits
+        # `Range[T]` for every T (`Range[Integer?]` is the common core spelling of the slicing param).
+        #
+        # Known coarse spot, deliberately not special-cased: a mixed-endpoint literal (`1.0..2`) is
+        # rejected by `Range[Integer]` and by `Range[Float]` alike, so overload selection falls through
+        # to its gradual pass and then to the first-overload fallback exactly as it did before.
+        def accepts_range_constant_type_arg(self_type, constant, mode)
+          return nil unless self_type.type_args.size == 1
+
+          endpoints = RangeConstant.literal_endpoints(constant)
+          return nil if endpoints.nil?
+
+          element = self_type.type_args.first
+          combine_range_endpoint_results(
+            endpoints.map { |endpoint| accepts(element, Type::Combinator.constant_of(endpoint), mode: mode) },
+            element,
+            mode
+          )
+        end
+
+        def combine_range_endpoint_results(per_endpoint, element, mode)
+          if per_endpoint.any?(&:no?)
+            Type::AcceptsResult.no(mode: mode, reasons: "a Range endpoint is rejected by #{element.describe}")
+          elsif per_endpoint.any?(&:maybe?)
+            Type::AcceptsResult.maybe(
+              mode: mode,
+              reasons: "a Range endpoint could not be proven accepted by #{element.describe}"
+            )
+          else
+            Type::AcceptsResult.yes(mode: mode, reasons: "every Range endpoint accepted by #{element.describe}")
+          end
+        end
+
         # IntegerRange[a..b] accepts:
         # - Constant[n] where n is an Integer covered by [a..b];
         # - IntegerRange[c..d] where [c..d] ⊆ [a..b];
-        # - Nominal[Integer] only when self is the universal range (`int<min, max>`), since otherwise an
+        # - Nominal[Integer] only when self is the universal range (`Integer[min..max]`), since otherwise an
         #   arbitrary Integer could fall outside the bound.
         # Anything else is rejected.
         def accepts_integer_range(self_type, other_type, mode)
@@ -616,6 +693,65 @@ module Rigor
           end
         end
 
+        # ADR-109 WD4 — `FloatRange` accepts:
+        # - Constant[f] where f is a Float the range covers (never NaN: `cover?` compares);
+        # - FloatRange[c..d] whose canonical closed bounds sit inside self's.
+        # `Nominal[Float]` is never accepted, not even by the universal range: an arbitrary Float may be
+        # NaN, and the universal range is exactly "every Float except NaN".
+        def accepts_float_range(self_type, other_type, mode)
+          case other_type
+          when Type::Constant
+            accepts_float_range_from_constant(self_type, other_type, mode)
+          when Type::FloatRange
+            accepts_float_range_from_float_range(self_type, other_type, mode)
+          when Type::Nominal
+            Type::AcceptsResult.no(
+              mode: mode,
+              reasons: "#{self_type.describe} rejects Nominal[#{other_type.class_name}] (could be NaN or fall outside)"
+            )
+          else
+            Type::AcceptsResult.no(
+              mode: mode,
+              reasons: "FloatRange rejects #{other_type.class}"
+            )
+          end
+        end
+
+        def accepts_float_range_from_constant(self_type, constant, mode)
+          unless constant.value.is_a?(Float)
+            return Type::AcceptsResult.no(
+              mode: mode,
+              reasons: "FloatRange rejects non-Float Constant"
+            )
+          end
+
+          if self_type.covers?(constant.value)
+            Type::AcceptsResult.yes(
+              mode: mode,
+              reasons: "Constant[#{constant.value}] is in #{self_type.describe}"
+            )
+          else
+            Type::AcceptsResult.no(
+              mode: mode,
+              reasons: "Constant[#{constant.value}] outside #{self_type.describe}"
+            )
+          end
+        end
+
+        def accepts_float_range_from_float_range(self_type, other_range, mode)
+          if self_type.min <= other_range.min && other_range.canonical_max <= self_type.canonical_max
+            Type::AcceptsResult.yes(
+              mode: mode,
+              reasons: "#{other_range.describe} ⊆ #{self_type.describe}"
+            )
+          else
+            Type::AcceptsResult.no(
+              mode: mode,
+              reasons: "#{other_range.describe} not contained in #{self_type.describe}"
+            )
+          end
+        end
+
         # `Difference[base, removed]` accepts another type X when the base accepts X *and* X's value set is
         # provably disjoint from `removed`. The disjointness test is the subtle part — it is NOT the same as
         # `removed.accepts(X)`, because `Nominal[String]` includes `""` even though `Constant[""]` does not
@@ -936,7 +1072,7 @@ module Rigor
         def resolve_class(name)
           return nil unless name.is_a?(::String)
 
-          parts = name.delete_prefix("::").split("::")
+          parts = class_name_parts(name)
           return nil if parts.empty?
 
           mod = ::Object
@@ -950,7 +1086,16 @@ module Rigor
         rescue ::StandardError, ::ScriptError, ::SystemExit
           nil
         end
+
+        # #775 — the split of a class name is a pure function of the string, and the subtype check asks it
+        # twice per Nominal-vs-Nominal comparison (~370k times on the lib self-check) for the same few
+        # hundred names. Only the split is memoised; the constant walk above still runs every time, so a
+        # class loaded (or a spec constant removed) after the first ask is answered by the live tree.
+        def class_name_parts(name)
+          @class_name_parts[name] ||= name.delete_prefix("::").split("::").freeze
+        end
       end
+      @class_name_parts = {}
     end
   end
 end

data/lib/rigor/inference/block_parameter_binder.rb

@@ -34,15 +34,14 @@ module Rigor
     #
     # See docs/internal-spec/inference-engine.md for the binding contract.
     class BlockParameterBinder
-      # @param expected_param_types [Array<Rigor::Type>] positional block parameter types in order. Indices
+      # @param expected_param_types — positional block parameter types in order. Indices
       #   the binder cannot fill from this array (because the array is shorter than the parameter list, or
       #   because the slot is a kind we do not pull from the array) default to `Dynamic[Top]`.
       def initialize(expected_param_types: [])
         @expected_param_types = expected_param_types
       end
 
-      # @param block_node [Prism::BlockNode]
-      # @return [Hash{Symbol => Rigor::Type}] ordered map from parameter name to bound type. Anonymous
+      # @return ordered map from parameter name to bound type. Anonymous
       #   parameters are skipped; MultiTargetNode destructuring slots delegate to {MultiTargetBinder} and
       #   contribute every named local in declaration order. Numbered-parameter forms (`_1`, `_2`, ...) bind
       #   `:_1`, `:_2`, ... up to the maximum the block body refers to.

data/lib/rigor/inference/body_fixpoint.rb

@@ -26,12 +26,12 @@ module Rigor
 
       module_function
 
-      # @param names [Array<Symbol>] the outer locals the body can rebind.
-      # @param seed_bindings [Hash{Symbol=>Type}] pre-state binding per name.
-      # @param widen [#call] value-pinned widener (Constant -> Nominal).
-      # @param evaluate_body [#call] `bindings -> exit_bindings` — evaluates the body once from `bindings`
+      # @param names — the outer locals the body can rebind.
+      # @param seed_bindings — pre-state binding per name.
+      # @param widen — value-pinned widener (Constant -> Nominal).
+      # @param evaluate_body — `bindings -> exit_bindings` — evaluates the body once from `bindings`
       #   (the per-name current assumption) and returns the per-name exit binding it produced.
-      # @return [Hash{Symbol=>Type}] the continuation binding per name.
+      # @return the continuation binding per name.
       def converge(names:, seed_bindings:, widen:, evaluate_body:)
         return {} if names.empty?
 

data/lib/rigor/inference/budget_trace.rb

@@ -65,8 +65,6 @@ module Rigor
       #   plain `(receiver, method)` signature was already on the recursion guard stack.
       # - {MEMO_REFUSE_UNROLL} — pre-ADR-84 blanket refusal (constant-arg unroll in flight). Kept in the table
       #   as the ADR-84 WD3 gate pin: structurally unreachable, must read ~0.
-      # - {MEMO_REFUSE_CONSULT_TAINTED} — a candidate frame computed a result but an ADR-55 fixpoint summary
-      #   was *consulted* during the compute, so the result is a transient Kleene iterate and was NOT stored.
       # - {MEMO_REFUSE_TRANSIENT} — ADR-84 WD3: a candidate frame's compute bracket saw a
       #   transient-machinery event (recursion-guard hit / unroll-fuel exhaustion / ADR-55 WD1 clamp /
       #   fixpoint-cap collapse — `ExpressionTyper#note_transient_fallback`) that referenced a stack frame
@@ -79,15 +77,13 @@ module Rigor
       MEMO_BODY_EVALS = :memo_body_evals
       MEMO_REFUSE_ON_STACK = :memo_refuse_on_stack
       MEMO_REFUSE_UNROLL = :memo_refuse_unroll
-      MEMO_REFUSE_CONSULT_TAINTED = :memo_refuse_consult_tainted
       MEMO_REFUSE_TRANSIENT = :memo_refuse_transient
 
       CATEGORIES = [
         RECURSION_GUARD, ANCESTOR_WALK_LIMIT, HKT_FUEL_EXHAUSTED, RECURSION_UNROLL_FUEL,
         RECURSION_FIXPOINT_CAP, BLOCK_WRITEBACK_CAP,
         MEMO_ENTRIES, MEMO_HITS, MEMO_MISSES, MEMO_BODY_EVALS,
-        MEMO_REFUSE_ON_STACK, MEMO_REFUSE_UNROLL, MEMO_REFUSE_CONSULT_TAINTED,
-        MEMO_REFUSE_TRANSIENT
+        MEMO_REFUSE_ON_STACK, MEMO_REFUSE_UNROLL, MEMO_REFUSE_TRANSIENT
       ].freeze
 
       # Distribution (histogram) categories — read-only observations of a value's size at a site, used to

data/lib/rigor/inference/captured_locals.rb

@@ -30,9 +30,8 @@ module Rigor
 
       module_function
 
-      # @param block_node [Prism::BlockNode]
-      # @param base_scope [Rigor::Scope] the call-site scope the block closes over.
-      # @return [Array<Symbol>] the captured names the body writes, each once, in first-write order.
+      # @param base_scope — the call-site scope the block closes over.
+      # @return the captured names the body writes, each once, in first-write order.
       def writes(block_node, base_scope)
         body = block_node.body
         return [] if body.nil?

data/lib/rigor/inference/closure_escape_analyzer.rb

@@ -51,11 +51,9 @@ module Rigor
     module ClosureEscapeAnalyzer
       module_function
 
-      # @param receiver_type [Rigor::Type, nil]
-      # @param method_name [Symbol]
-      # @param environment [Rigor::Environment, nil] reserved for the future sub-phase that consults
+      # @param environment — reserved for the future sub-phase that consults
       #   `RBS::Extended` call-timing effects; sub-phase 3a ignores it.
-      # @return [Symbol] one of `:non_escaping`, `:escaping`, `:unknown`.
+      # @return one of `:non_escaping`, `:escaping`, `:unknown`.
       def classify(receiver_type:, method_name:, environment: nil) # rubocop:disable Lint/UnusedMethodArgument
         return :unknown if receiver_type.nil?
 

data/lib/rigor/inference/coverage_scanner.rb

@@ -22,17 +22,17 @@ module Rigor
     # a tracer per visited node and discards the inferred type values.
     class CoverageScanner
       class Result < Data.define(:visits, :unrecognized, :events)
-        # @return [Integer] sum of all visits across node classes.
+        # @return sum of all visits across node classes.
         def visited_count
           visits.values.sum
         end
 
-        # @return [Integer] sum of directly-unrecognized counts across classes.
+        # @return sum of directly-unrecognized counts across classes.
         def unrecognized_count
           unrecognized.values.sum
         end
 
-        # @return [Float] unrecognized_count / visited_count, or 0.0 when empty.
+        # @return unrecognized_count / visited_count, or 0.0 when empty.
         def unrecognized_ratio
           total = visited_count
           return 0.0 if total.zero?
@@ -41,13 +41,11 @@ module Rigor
         end
       end
 
-      # @param scope [Rigor::Scope] base scope used for every type_of call. Defaults to `Scope.empty`.
+      # @param scope — base scope used for every type_of call. Defaults to `Scope.empty`.
       def initialize(scope: nil)
         @scope = scope || Scope.empty
       end
 
-      # @param root [Prism::Node]
-      # @return [Result]
       def scan(root)
         visits = Hash.new(0)
         unrecognized = Hash.new(0)