rigortype 0.1.4 → 0.1.6

data/lib/rigor/environment.rb

@@ -2,6 +2,17 @@
 
 require_relative "environment/class_registry"
 require_relative "environment/rbs_loader"
+require_relative "environment/reflection"
+require_relative "environment/reporters"
+require_relative "environment/hkt_registry_holder"
+require_relative "environment/bundle_sig_discovery"
+require_relative "environment/lockfile_resolver"
+require_relative "environment/rbs_collection_discovery"
+require_relative "environment/rbs_coverage_report"
+require_relative "inference/synthetic_method_index"
+require_relative "inference/project_patched_methods"
+require_relative "inference/hkt_registry"
+require_relative "builtins/hkt_builtins"
 require_relative "type_node/name_scope"
 require_relative "type_node/resolver_chain"
 
@@ -40,11 +51,19 @@ module Rigor
       pathname optparse json yaml fileutils tempfile tmpdir
       stringio forwardable digest securerandom
       uri logger date
+      pp delegate observable abbrev find tsort singleton
+      shellwords benchmark base64 did_you_mean
+      monitor mutex_m timeout
+      open3 erb etc ipaddr bigdecimal bigdecimal-math
+      prettyprint random-formatter time open-uri resolv
+      csv pstore objspace io-console cgi cgi-escape
+      strscan
       prism rbs
     ].freeze
 
     attr_reader :class_registry, :rbs_loader, :plugin_registry, :dependency_source_index,
-                :rbs_extended_reporter, :boundary_cross_reporter, :name_scope
+                :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
@@ -65,22 +84,105 @@ module Rigor
     #   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,
+    def initialize(class_registry: ClassRegistry.default, rbs_loader: nil, # rubocop:disable Metrics/ParameterLists
                    plugin_registry: nil, dependency_source_index: nil,
-                   rbs_extended_reporter: nil, boundary_cross_reporter: nil)
+                   rbs_extended_reporter: nil, boundary_cross_reporter: nil,
+                   synthetic_method_index: nil, project_patched_methods: nil,
+                   hkt_registry: nil)
       @class_registry = class_registry
       @rbs_loader = rbs_loader
       @plugin_registry = plugin_registry
       @dependency_source_index = dependency_source_index
-      @rbs_extended_reporter = rbs_extended_reporter
-      @boundary_cross_reporter = boundary_cross_reporter
+      # ADR-pending — reporters live in a mutable container so
+      # long-lived integrations (LSP `ProjectContext`) can swap
+      # them per `Runner.run` without rebuilding the env. The
+      # existing `#rbs_extended_reporter` / `#boundary_cross_reporter`
+      # accessors below preserve the public lookup shape.
+      @reporters = Reporters.new(
+        rbs_extended: rbs_extended_reporter,
+        boundary_cross: boundary_cross_reporter
+      )
+      @synthetic_method_index = synthetic_method_index || Inference::SyntheticMethodIndex::EMPTY
+      @project_patched_methods = project_patched_methods || Inference::ProjectPatchedMethods::EMPTY
+      # ADR-20 slice 2c + 2e — the per-env HKT registry
+      # consulted by the reducer when resolving `Type::App`
+      # carriers. Defaults to {Inference::HktRegistry::EMPTY};
+      # the {.default} / {.for_project} class methods seed it
+      # with the bundled builtins (`json::value`, …) plus any
+      # `%a{rigor:v1:hkt_register / hkt_define}` annotations
+      # the RBS loader exposes. The hkt_registry getter
+      # (defined below) MEMOIZES the result of merging the
+      # base with the RBS scan so the scan is paid at most
+      # once per Environment lifetime — and only when first
+      # consulted, leaving fast paths like `rigor check
+      # --cache-stats --no-stats` from doing the RBS env
+      # build at all.
+      @hkt_registry_base = hkt_registry || Inference::HktRegistry::EMPTY
+      @hkt_registry_holder = HktRegistryHolder.new
       @name_scope = build_name_scope
       freeze
     end
 
+    # ADR-20 slices 2e + 6 — lazy HKT registry getter.
+    # Merge order on first call: builtins (base) ← plugin
+    # manifest aggregation ← RBS env scan. Last-write-wins on
+    # URI collisions so user-authored `.rbs` overlays 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).
+    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
+        )
+      end
+    end
+
+    # Backwards-compatible reporter accessors — every existing
+    # consumer (rbs_extended, method_dispatcher) calls these. The
+    # frozen `@reporters` container is mutable for slot reassignment
+    # via {#attach_reporters!} below.
+    def rbs_extended_reporter
+      @reporters.rbs_extended
+    end
+
+    def boundary_cross_reporter
+      @reporters.boundary_cross
+    end
+
+    # Replaces the env's per-run reporter slots. Intended for
+    # long-lived integrations (LSP `ProjectContext`) that share one
+    # Environment instance across many `Runner.run` calls: each call
+    # attaches its own fresh reporter pair so per-call diagnostic
+    # events stay scoped to that call rather than accumulating
+    # across publishes.
+    #
+    # Single-threaded use only. Concurrent publishes against one
+    # Environment must serialise — the LSP `Server` debouncer +
+    # synchronized writer already enforces this for the editor
+    # path. The Ractor pool path builds a per-worker Environment
+    # and does not reach this surface.
+    def attach_reporters!(rbs_extended_reporter:, boundary_cross_reporter:)
+      @reporters.rbs_extended = rbs_extended_reporter
+      @reporters.boundary_cross = boundary_cross_reporter
+      nil
+    end
+
     class << self
       def default
-        @default ||= new(rbs_loader: RbsLoader.default).freeze
+        @default ||= new(
+          rbs_loader: RbsLoader.default,
+          hkt_registry: Builtins::HktBuiltins.registry
+        ).freeze
       end
 
       # Builds an Environment that consults the project's local
@@ -104,24 +206,80 @@ module Rigor
       #   reflection artefacts) consult the cache. Pass `nil` (the
       #   default) to skip caching for this environment.
       # @return [Rigor::Environment]
-      def for_project(root: Dir.pwd, libraries: [], signature_paths: nil, cache_store: nil, # rubocop:disable Metrics/ParameterLists
+      # rubocop:disable Metrics/MethodLength, Metrics/ParameterLists
+      def for_project(root: Dir.pwd, libraries: [], signature_paths: nil, cache_store: nil,
                       plugin_registry: nil, dependency_source_index: nil,
-                      rbs_extended_reporter: nil, boundary_cross_reporter: nil)
+                      rbs_extended_reporter: nil, boundary_cross_reporter: nil,
+                      bundler_bundle_path: nil, bundler_auto_detect: false,
+                      bundler_lockfile: nil,
+                      rbs_collection_lockfile: nil, rbs_collection_auto_detect: false,
+                      synthetic_method_index: nil, project_patched_methods: nil)
         resolved_paths = signature_paths || default_signature_paths(root)
+        # O4 MVP — append per-gem `sig/` directories discovered
+        # under the target project's bundler install root. Empty
+        # array when neither an explicit path nor auto-detection
+        # finds a bundle. Order: user `signature_paths:` win first
+        # (semantic precedence inside `RbsLoader.build_env_for`);
+        # gem-shipped sigs append last so user overrides stay
+        # authoritative.
+        #
+        # O4 Layer 3 — when a Gemfile.lock is available (explicit
+        # `bundler_lockfile:` or auto-detected next to the project
+        # root), use the locked gem set to filter the discovered
+        # `sig/` directories. Stale gems in the bundle install
+        # tree (out-of-band installs, version drift after a
+        # `bundle update`) are silently dropped so only gems the
+        # project actually declares contribute RBS.
+        locked = LockfileResolver.locked_gems(
+          lockfile_path: bundler_lockfile,
+          project_root: root,
+          auto_detect: bundler_auto_detect
+        )
+        gem_sig_paths = BundleSigDiscovery.discover(
+          bundle_path: bundler_bundle_path,
+          project_root: root,
+          auto_detect: bundler_auto_detect,
+          locked_gems: locked.empty? ? nil : locked
+        ).map(&:to_s)
+        # O4 Layer 3 slice 2 — when `rbs collection install`
+        # has been run for the target project, parse the
+        # resulting `rbs_collection.lock.yaml` and feed each
+        # gem's `<collection_path>/<name>/<version>/` directory
+        # into `signature_paths:`. Stdlib-typed entries are
+        # skipped (already covered by `DEFAULT_LIBRARIES`).
+        collection_paths = RbsCollectionDiscovery.discover(
+          lockfile_path: rbs_collection_lockfile,
+          project_root: root,
+          auto_detect: rbs_collection_auto_detect
+        ).map(&:to_s)
+        loader_signature_paths = resolved_paths + gem_sig_paths + collection_paths
         merged_libraries = (DEFAULT_LIBRARIES + libraries.map(&:to_s)).uniq
         loader = RbsLoader.new(
           libraries: merged_libraries,
-          signature_paths: resolved_paths,
+          signature_paths: loader_signature_paths,
           cache_store: cache_store
         )
+        # 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 up front. URI
+        # collisions let the user-authored overlay win over
+        # the bundled builtin (last-write-wins per ADR-20
+        # OQ3 tentative).
         new(
           rbs_loader: loader,
           plugin_registry: plugin_registry,
           dependency_source_index: dependency_source_index,
           rbs_extended_reporter: rbs_extended_reporter,
-          boundary_cross_reporter: boundary_cross_reporter
+          boundary_cross_reporter: boundary_cross_reporter,
+          synthetic_method_index: synthetic_method_index,
+          project_patched_methods: project_patched_methods,
+          hkt_registry: Builtins::HktBuiltins.registry
         )
       end
+      # rubocop:enable Metrics/MethodLength, Metrics/ParameterLists
 
       private
 
@@ -185,6 +343,17 @@ module Rigor
       class_known_in_rbs?(name)
     end
 
+    # ADR-15 Phase 2b — returns the loader's read-only,
+    # `Ractor.shareable?` query surface as a frozen
+    # {Environment::Reflection}. Built lazily on first
+    # access; subsequent calls return the same instance.
+    # Returns `nil` when the environment carries no RBS
+    # loader (test-only `Environment.new` without
+    # `rbs_loader:`).
+    def reflection
+      @rbs_loader&.reflection
+    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

data/lib/rigor/inference/acceptance.rb

@@ -327,10 +327,44 @@ module Rigor
           )
           return class_result if class_result.no?
 
-          args_result = accepts_nominal_args(self_type, other_type, mode)
+          # Parametrized-ancestor projection. When `actual <:= target`
+          # holds at the class level but the type-arg arities differ,
+          # the actual's parametrization has to be projected into the
+          # target's view before the element-wise covariance check.
+          # The canonical case is `Hash[K, V] <:= Enumerable[[K, V]]`:
+          # Hash carries two type_args, Enumerable carries one, and
+          # the inherited parametrization at the Enumerable boundary
+          # is `Tuple[K, V]`. RBS encodes this as
+          # `include Enumerable[[K, V]]` in `Hash`'s definition.
+          projected_other = project_to_target_arity(self_type, other_type) || other_type
+          args_result = accepts_nominal_args(self_type, projected_other, mode)
           combine_results(class_result, args_result, mode)
         end
 
+        # Returns `other_type` rewritten so its type_args have the
+        # same arity as `self_type.type_args`, or `nil` if no
+        # projection is known. Today only the Hash → Enumerable
+        # projection is hand-rolled; a general RBS-driven
+        # implementation that consults `definition.ancestors[i].args`
+        # for arbitrary subclass / module-include relations is the
+        # principled follow-up.
+        def project_to_target_arity(self_type, other_type)
+          return nil if self_type.type_args.size == other_type.type_args.size
+          return nil if self_type.type_args.empty? || other_type.type_args.empty?
+
+          if self_type.class_name == "Enumerable" &&
+             other_type.class_name == "Hash" &&
+             self_type.type_args.size == 1 &&
+             other_type.type_args.size == 2
+            return Type::Combinator.nominal_of(
+              "Hash",
+              type_args: [Type::Combinator.tuple_of(*other_type.type_args)]
+            )
+          end
+
+          nil
+        end
+
         def project_tuple_to_nominal(tuple)
           if tuple.elements.empty?
             Type::Combinator.nominal_of(Array)
@@ -412,13 +446,45 @@ module Rigor
 
         def accepts_nominal_from_constant(self_type, constant, mode)
           ruby_class = resolve_class(self_type.class_name)
-          if ruby_class.nil?
-            return Type::AcceptsResult.maybe(
+          return constant_is_a_result(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 ancestor chain — always loadable
+          # because the value already exists. Required for
+          # OverloadSelector to reject `Integer#+(BigDecimal) ->
+          # BigDecimal` overloads contributed by `bigdecimal`'s
+          # RBS reopening when the actual arg is a Constant<Integer>.
+          ancestor_names = constant.value.class.ancestors.map(&:name)
+          if ancestor_names.include?(self_type.class_name)
+            Type::AcceptsResult.yes(
               mode: mode,
-              reasons: "class #{self_type.class_name} not loadable; cannot prove from Constant"
+              reasons: "Constant value class ancestors include #{self_type.class_name}"
+            )
+          else
+            Type::AcceptsResult.no(
+              mode: mode,
+              reasons: "Constant value class ancestors exclude #{self_type.class_name}"
+            )
+          end
+        end
+
+        def subtype_result_via_ancestors(actual_class, target_name, mode)
+          if actual_class.ancestors.map(&:name).include?(target_name)
+            Type::AcceptsResult.yes(
+              mode: mode,
+              reasons: "#{actual_class.name} ancestors include #{target_name}"
+            )
+          else
+            Type::AcceptsResult.no(
+              mode: mode,
+              reasons: "#{actual_class.name} ancestors exclude #{target_name} (target unloadable)"
             )
           end
+        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})")
           else
@@ -760,6 +826,19 @@ module Rigor
 
           target_class = resolve_class(target_name)
           actual_class = resolve_class(actual_name)
+          # When only `actual` resolves, we can still rule out
+          # `actual <:= target` by inspecting `actual`'s ancestor
+          # chain. The canonical case: `target=BigDecimal` is not
+          # loadable in the host process (no `require` in rigor's
+          # own runtime), but `actual=Integer` IS, and Integer's
+          # ancestors do not include `BigDecimal`, so the subtype
+          # relation MUST be `:no` rather than the conservative
+          # `:maybe`. The reverse asymmetry (target resolves,
+          # actual doesn't) does not let us conclude anything —
+          # the unloaded `actual` could be an unrelated class or
+          # a subclass of `target` we can't see, so we still
+          # answer `:maybe` there.
+          return subtype_result_via_ancestors(actual_class, target_name, mode) if target_class.nil? && actual_class
           if target_class.nil? || actual_class.nil?
             return Type::AcceptsResult.maybe(
               mode: mode,

data/lib/rigor/inference/builtins/method_catalog.rb

@@ -30,7 +30,16 @@ module Rigor
         def initialize(path:, mutating_selectors: {})
           @path = path
           @mutating_selectors = mutating_selectors.transform_values(&:freeze).freeze
-          @catalog = nil
+          # ADR-15 Phase 4b.x — eager-load so the instance is
+          # safe to `Ractor.make_shareable`. Lazy init via
+          # `@catalog ||= load_catalog` would write to a
+          # potentially-frozen instance the first time a
+          # worker Ractor consults the catalog, raising
+          # `FrozenError`. The YAML parse is a once-per-process
+          # cost and the catalogs are constructed at module
+          # load time anyway, so eager init is free in
+          # practice.
+          @catalog = load_catalog
         end
 
         def safe_for_folding?(class_name, selector, kind: :instance)
@@ -52,7 +61,7 @@ module Rigor
         end
 
         def reset!
-          @catalog = nil
+          @catalog = load_catalog
         end
 
         private
@@ -72,9 +81,7 @@ module Rigor
           per_class.include?(selector.to_sym) || per_class.include?(selector_str.to_sym)
         end
 
-        def catalog
-          @catalog ||= load_catalog
-        end
+        attr_reader :catalog
 
         def load_catalog
           return EMPTY_CATALOG unless File.exist?(@path)

data/lib/rigor/inference/builtins/numeric_catalog.rb

@@ -68,15 +68,21 @@ module Rigor
           # Used by tests to drop the cached catalog so a different
           # path or content can be exercised. Production code MUST
           # NOT call this during normal operation.
+          #
+          # ADR-15 Phase 4b.x — reset re-loads eagerly so the
+          # singleton-class `@catalog` ivar stays populated, and
+          # the loaded Hash is deep-shared via `Ractor.make_shareable`
+          # so a worker Ractor reading the ivar via `catalog.dig(...)`
+          # does not trip `Ractor::IsolationError`. Plain `.freeze`
+          # is insufficient: YAML parses to a nested Hash/Array/String
+          # graph and only the outer Hash would be frozen.
           def reset!
-            @catalog = nil
+            @catalog = Ractor.make_shareable(load_catalog)
           end
 
           private
 
-          def catalog
-            @catalog ||= load_catalog
-          end
+          attr_reader :catalog
 
           def load_catalog
             return EMPTY_CATALOG unless File.exist?(CATALOG_PATH)
@@ -87,6 +93,11 @@ module Rigor
             EMPTY_CATALOG
           end
         end
+
+        # ADR-15 Phase 4b.x — eager-load on the main Ractor at
+        # module-load time so worker Ractors only READ the
+        # populated singleton-class `@catalog` ivar.
+        reset!
       end
     end
   end

data/lib/rigor/inference/expression_typer.rb

@@ -6,6 +6,7 @@ require_relative "../type"
 require_relative "../ast"
 require_relative "block_parameter_binder"
 require_relative "fallback"
+require_relative "macro_block_self_type"
 require_relative "method_dispatcher"
 
 module Rigor
@@ -60,6 +61,10 @@ module Rigor
         Prism::RationalNode => :type_of_literal_value,
         Prism::SymbolNode => :symbol_type_for,
         Prism::StringNode => :string_type_for,
+        Prism::XStringNode => :type_of_xstring,
+        Prism::InterpolatedXStringNode => :type_of_xstring,
+        Prism::SourceFileNode => :type_of_source_file,
+        Prism::SourceLineNode => :type_of_source_line,
         Prism::TrueNode => :type_of_true,
         Prism::FalseNode => :type_of_false,
         Prism::NilNode => :type_of_nil,
@@ -143,6 +148,9 @@ module Rigor
         Prism::AliasMethodNode => :type_of_nil_value,
         Prism::AliasGlobalVariableNode => :type_of_nil_value,
         Prism::UndefNode => :type_of_nil_value,
+        Prism::PostExecutionNode => :type_of_nil_value,
+        Prism::ShareableConstantNode => :type_of_shareable_constant,
+        Prism::ImplicitNode => :type_of_implicit,
         Prism::ForwardingSuperNode => :type_of_dynamic_top,
         Prism::BlockArgumentNode => :type_of_non_value,
         # Parameters and blocks (non-value positions)
@@ -158,6 +166,7 @@ module Rigor
         Prism::ForwardingParameterNode => :type_of_non_value,
         Prism::NoKeywordsParameterNode => :type_of_non_value,
         Prism::ImplicitRestNode => :type_of_non_value,
+        Prism::ItParametersNode => :type_of_non_value,
         Prism::BlockNode => :type_of_dynamic_top,
         Prism::SplatNode => :type_of_non_value,
         # Control flow (Slice 3 phase 1): branch types are unioned, jumps
@@ -887,6 +896,45 @@ module Rigor
         Type::Combinator.constant_of(unescaped)
       end
 
+      # Backtick (`cmd`) and `%x{cmd}` invoke Kernel#` and always return a
+      # String. Even when the content is statically known, we widen to
+      # Nominal[String] because the runtime value depends on the
+      # subprocess output, not the source text.
+      def type_of_xstring(_node)
+        Type::Combinator.nominal_of(String)
+      end
+
+      # __FILE__ is the source file path. Always non-empty when
+      # parsing a real file (the path resolver gives the buffer
+      # name, which is at minimum `"(stdin)"` / `"-e"` / a real
+      # path — never the empty String). Widened to
+      # `non-empty-string` instead of `Nominal[String]` so
+      # downstream String-emptiness checks know the value cannot
+      # be `""`.
+      def type_of_source_file(_node)
+        Type::Combinator.non_empty_string
+      end
+
+      # __LINE__ is the line of the source literal. Ruby line
+      # numbers are 1-indexed, so `__LINE__` is always at least
+      # 1 — `positive-int` (Integer in `[1, +Inf)`) is the
+      # canonical refinement.
+      def type_of_source_line(_node)
+        Type::Combinator.positive_int
+      end
+
+      # `# shareable_constant_value:` magic comment wraps the next
+      # constant write. Type is the wrapped write's value.
+      def type_of_shareable_constant(node)
+        type_of(node.write)
+      end
+
+      # `{ x: }` shorthand hash. The implicit value is the call to
+      # `x` (or a local read of `x`). Delegate.
+      def type_of_implicit(node)
+        type_of(node.value)
+      end
+
       def local_read(node)
         scope.local(node.name) || dynamic_top
       end
@@ -1194,16 +1242,25 @@ module Rigor
           arg_types: arg_types,
           environment: scope.environment
         )
-        block_return_for(block_arg, expected)
+        # ADR-16 Tier A: when a registered plugin's `block_as_methods`
+        # entry matches `(receiver_type, call_node.name)`, narrow the
+        # block body's `self_type` to the receiver class's instance
+        # type. The narrowing is `nil` for unmatched calls, leaving
+        # the existing scope contract unchanged.
+        narrowed_self = MacroBlockSelfType.narrow_self_type_for(
+          scope: scope, call_node: call_node, receiver_type: receiver_type
+        )
+        block_return_for(block_arg, expected, narrowed_self_type: narrowed_self)
       rescue StandardError
         nil
       end
 
-      def block_return_for(block_arg, expected)
+      def block_return_for(block_arg, expected, narrowed_self_type: nil)
         case block_arg
         when Prism::BlockNode
           bindings = BlockParameterBinder.new(expected_param_types: expected).bind(block_arg)
           block_scope = bindings.reduce(scope) { |acc, (name, type)| acc.with_local(name, type) }
+          block_scope = block_scope.with_self_type(narrowed_self_type) if narrowed_self_type
           type_block_body(block_arg, block_scope)
         when Prism::BlockArgumentNode
           symbol_block_return_type(block_arg, expected)