rigortype 0.3.7 → 0.3.9

data/lib/rigor/environment.rb

@@ -8,10 +8,12 @@ require_relative "environment/rbs_loader"
 require_relative "environment/reflection"
 require_relative "environment/reporters"
 require_relative "environment/hkt_registry_holder"
+require_relative "environment/failure_slot"
 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"
@@ -47,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
@@ -88,6 +89,10 @@ module Rigor
       # --no-stats` from doing the RBS env build at all.
       @hkt_registry_base = hkt_registry || Inference::HktRegistry::EMPTY
       @hkt_registry_holder = HktRegistryHolder.new
+      # Issue #784 — where either stage of the HKT-registry build (the plugin overlay, #791; the RBS
+      # `type`-alias scan) records a raise, so it surfaces once for the run instead of once per file — or,
+      # for the overlay, instead of aborting the run outright (see {#hkt_registry}).
+      @hkt_scan_failure = FailureSlot.new
       @constant_type_cache = ConstantTypeCacheHolder.new
       # ADR-82 WD9 — `[gem_name, version]` pairs for the locked gems with no resolvable RBS. The
       # root-constant ownership index over them is built lazily (first unresolved constant read) so runs
@@ -104,21 +109,91 @@ module Rigor
     # beat plugin entries, which beat the bundled JSON_VALUE. Memoised; single-threaded use only (under the
     # Ractor pool path each worker has its own Environment so cross-worker mutation is impossible; the LSP
     # single-publish-at-a-time invariant serialises here).
+    #
+    # BOTH stages are guarded (#784, #791): whichever raises is recorded on {#hkt_scan_failure} with the
+    # stage that failed and the other stage still runs, so this getter never raises into its callers —
+    # neither into a file's `analyze_body` rescue nor out of the run-owned demands, which have no rescue
+    # above them at all.
     def hkt_registry
       @hkt_registry_holder.fetch do
-        with_plugin_overlay = if @plugin_registry.respond_to?(:hkt_overlay_registry)
-                                @hkt_registry_base.merge(@plugin_registry.hkt_overlay_registry)
-                              else
-                                @hkt_registry_base
-                              end
-        Inference::HktRegistry.scan_rbs_loader(
-          @rbs_loader,
-          base: with_plugin_overlay,
-          reporter: rbs_extended_reporter
-        )
+        pre_scan = pre_scan_hkt_registry
+        begin
+          Inference::HktRegistry.scan_rbs_loader(
+            @rbs_loader,
+            base: pre_scan,
+            reporter: rbs_extended_reporter
+          )
+        rescue StandardError => e
+          # Issue #784 — the seam. This build is shared and memoised, and it is first demanded from inside
+          # a file's analysis, so a raise here would otherwise land in every file's `analyze_body` rescue
+          # and turn the whole run into N identical `internal analyzer error` rows (issue #776). Record it
+          # and degrade to the pre-scan registry: analysis proceeds, HKT inference from RBS `type` aliases
+          # reads its bound (`Dynamic[top]`, ADR-20 WD2), and the run surfaces ONE
+          # `rbs.coverage.hkt-scan-failed` row. Not a silent skip — the row is `:error` and names the
+          # exception and raise site — and the same shape as `RbsLoader#record_env_build_failure`.
+          # Memoising the degraded registry is what keeps the scan from being re-attempted per file.
+          record_hkt_registry_failure(e, stage: :scan)
+          pre_scan
+        end
       end
     end
 
+    # Issue #791 — the OTHER build behind {#hkt_registry}, and the reason the seam covers two stages
+    # rather than one. Aggregating the loaded plugins' manifest-declared HKT entries runs plugin-authored
+    # code (`Plugin::Registry#hkt_overlay_registry` reads each manifest); before this it sat one line ABOVE
+    # the #784 rescue, so a raise there escaped {#hkt_registry} entirely. Post-#788 that is not a per-file
+    # crash storm but an uncaught abort: {HktRegistryHolder#fetch} memoises only on success, so the raise
+    # is re-attempted at every demand, and the run-owned demands (`Runner::PoolCoordinator#hkt_scan_outcome`
+    # after the file loop, `Analysis::WorkerSession#drain_reporters`) sit outside any rescue.
+    #
+    # The degradation is narrower than the scan's: only the plugin overlay is dropped, and the RBS scan
+    # still runs on top of the bundled base, so a user's own `.rbs` HKT registrations survive a plugin
+    # 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 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)
+
+      @hkt_registry_base.merge(@plugin_registry.hkt_overlay_registry)
+    rescue StandardError => e
+      record_hkt_registry_failure(e, stage: :overlay)
+      @hkt_registry_base
+    end
+    private :pre_scan_hkt_registry
+
+    # Issue #784 — the `[error_class_name, first_message_line, raw_frame_or_nil, stage]` tuple the seam in
+    # {#hkt_registry} recorded, or nil when both stages built (or were never demanded). `stage` is `:scan`
+    # for the RBS `type`-alias scan and `:overlay` for the plugin-manifest aggregation (#791); it decides
+    # the row's wording, because "the implicit HKT scan over RBS `type` aliases raised" would point a user
+    # at their own `.rbs` for a plugin's defect. The run reads the tuple only after demanding
+    # {#hkt_registry} itself — after the file loop on the sequential paths, at drain time in each pool
+    # 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.
+    def hkt_scan_failure
+      @hkt_scan_failure.value
+    end
+
+    def record_hkt_registry_failure(error, stage:)
+      frames = error.backtrace || []
+      frame = frames.find { |f| f.include?("/lib/rigor/") } || frames.first
+      # `Class#name` is nil for an anonymous exception class; its nearest NAMED ancestor is the stable
+      # description (`inspect` embeds an object address, which would make the row's text differ across
+      # processes). Each String is frozen individually, not just the Array: the tuple crosses the fork
+      # boundary Marshal-clean and the drain channel's stated invariant
+      # ({Analysis::WorkerSession#drain_reporters}) is that its payload is also `Ractor.shareable?`, which a
+      # shallow freeze over `chomp`'s fresh String would not satisfy.
+      named = error.class.ancestors.find { |a| a.is_a?(Class) && a.name }
+      @hkt_scan_failure.record([
+                                 (error.class.name || "anonymous #{named&.name || 'Exception'}").dup.freeze,
+                                 error.message.to_s.lines.first.to_s.chomp.freeze,
+                                 frame&.dup&.freeze,
+                                 stage
+                               ])
+    end
+    private :record_hkt_registry_failure
+
     # ADR-82 WD9 — the gem name owning `root_constant_name`, when that gem is locked in the project's
     # Gemfile.lock, ships no resolvable RBS, and its entry file declares the constant at top level. Nil for
     # everything else — the caller then keeps the generic provenance cause. The index is built once, lazily,
@@ -178,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,
@@ -259,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
@@ -284,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
@@ -335,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
@@ -349,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
@@ -463,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
 
@@ -576,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.
@@ -600,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.