rigortype 0.4.1 → 0.4.3

data/lib/rigor/environment.rb

@@ -3,6 +3,7 @@
 require "digest"
 
 require_relative "environment/default_libraries"
+require_relative "environment/required_features"
 require_relative "environment/class_registry"
 require_relative "environment/rbs_loader"
 require_relative "environment/reflection"
@@ -96,7 +97,7 @@ module Rigor
       # 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
+      # ADR-82 WD9 — `[gem_name, version, variants]` entries for the locked gems with no resolvable RBS. The
       # root-constant ownership index over them is built lazily (first unresolved constant read) so runs
       # whose constants all resolve never pay the entry-file scan.
       @missing_rbs_gems = missing_rbs_gems.freeze
@@ -275,7 +276,7 @@ module Rigor
                       bundler_lockfile: nil,
                       rbs_collection_lockfile: nil, rbs_collection_auto_detect: false,
                       synthetic_method_index: nil, project_patched_methods: nil,
-                      source_files: [], locked_gems: nil)
+                      source_files: [], locked_gems: nil, required_features: nil)
         resolved_paths = project_signature_roots(signature_paths, root: 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
@@ -314,8 +315,10 @@ module Rigor
         # and the `data/vendored_gem_sigs/` bundle (`redis`, `nokogiri`, `pg`, …). `skip_gem_names:` passes
         # both sets so the collection copy doesn't double-declare against rigor's bundled RBS (the
         # `RBS::DuplicatedDeclarationError` hazard).
-        merged_libraries = (DEFAULT_LIBRARIES + libraries.map(&:to_s)).uniq
-        skip_gem_names = merged_libraries + RbsLoader.vendored_gem_names
+        # Issue #1700 — plus the gated vendored directories this run's source activates ({#feature_tokens}).
+        merged_libraries = (DEFAULT_LIBRARIES + libraries.map(&:to_s) +
+                            feature_tokens(required_features, source_files, libraries)).uniq
+        skip_gem_names = collection_skip_gem_names(merged_libraries)
         collection_paths = RbsCollectionDiscovery.discover(
           lockfile_path: rbs_collection_lockfile,
           project_root: root,
@@ -400,6 +403,21 @@ module Rigor
 
       private
 
+      # Issue #1700 — the `RequiredFeatures` library tokens for the gated vendored directories this run asks for:
+      # each feature its source requires and each one the configuration's `libraries:` names. `required_features`
+      # is the scan a caller already took; nil scans `source_files`. Whether a directory then loads is decided
+      # by `RbsLoader.build_env_for` against the environment it builds.
+      def feature_tokens(required_features, source_files, libraries)
+        RequiredFeatures.tokens(required_features || RequiredFeatures.scan(source_files), libraries)
+      end
+
+      # The gem names an `rbs collection` copy must not double-declare against: the library list and every
+      # vendored directory except a `RequiredFeatures`-gated one. A gated directory stands down for any other
+      # copy of its declarations (`GatedSignatureGuard`), so the collection's copy is kept and wins.
+      def collection_skip_gem_names(library_names)
+        library_names + RbsLoader.vendored_gem_names.reject { |name| RequiredFeatures.gated_dir?(name) }
+      end
+
       def default_signature_paths(root)
         sig = Pathname(root) / DEFAULT_PROJECT_SIG_DIR
         sig.directory? ? [sig] : []
@@ -426,8 +444,8 @@ module Rigor
       end
 
       # The `:missing` classification (locked gems with no RBS through any resolution path), computed once
-      # 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]`.
+      # and consumed twice: as `[gem_name, version, variants]` entries for the ADR-82 WD9 constant-ownership
+      # index, and as the eligible-gem set for the ADR-72 overlay resolution. Returns `[entries, overlay_paths]`.
       def missing_gems_and_overlay_paths(locked:, default_libraries:, bundle_sig_paths:,
                                          rbs_collection_paths:, plugin_registry:, signature_paths: [],
                                          bundle_root: nil)
@@ -440,7 +458,7 @@ module Rigor
           missing_gem_names: rows.map(&:gem_name), plugin_registry: plugin_registry,
           signature_paths: signature_paths
         )
-        [rows.map { |row| [row.gem_name, row.version] }, overlays]
+        [index_entries(rows, locked), overlays]
       end
 
       # Issue #530 — a project with no `Gemfile.lock` still has gems on disk, and before this it handed the
@@ -454,7 +472,14 @@ module Rigor
         return [[], []] if installed.empty?
 
         rows = missing_rows(installed, default_libraries, bundle_sig_paths, rbs_collection_paths)
-        [rows.map { |row| [row.gem_name, row.version] }, []]
+        [index_entries(rows, installed), []]
+      end
+
+      # The constant-ownership index's input: each `:missing` row with every `[version, platform]` variant its
+      # gem was locked (or found installed) under, because Bundler installs the variant matching the host —
+      # `commonmarker-2.10.0-arm64-darwin/` under a lockfile whose representative is the `ruby` one (#1844).
+      def index_entries(rows, gems)
+        rows.map { |row| [row.gem_name, row.version, gems[row.gem_name]&.variants] }
       end
 
       def missing_rows(gems, default_libraries, bundle_sig_paths, rbs_collection_paths)

data/lib/rigor/inference/acceptance.rb

@@ -486,7 +486,17 @@ module Rigor
             )
           end
 
-          nil
+          project_sequence_to_enumerator(self_type, other_type)
+        end
+
+        # `Enumerator::ArithmeticSequence[E]` carries only the element of its `Enumerator[Numeric, void]` superclass
+        # (#1794), so against a two-argument `Enumerator` it projects to `Enumerator[E, top]`, `top` being what RBS
+        # `void` translates to: `Enumerator[Integer, void]` and `[Integer, untyped]` accept it, as RBS would.
+        def project_sequence_to_enumerator(self_type, other_type)
+          return nil unless self_type.class_name == "Enumerator" && self_type.type_args.size == 2
+          return nil unless other_type.class_name == "Enumerator::ArithmeticSequence" && other_type.type_args.size == 1
+
+          Type::Combinator.nominal_of("Enumerator", type_args: [other_type.type_args.first, Type::Combinator.top])
         end
 
         def project_tuple_to_nominal(tuple)
@@ -963,11 +973,14 @@ module Rigor
           end
         end
 
-        # Constant[v] accepts only Constant[v'] with structurally equal value. Any other type is rejected
-        # (modulo the universal Bot/Dynamic short-circuits already applied upstream).
+        # Constant[v] accepts Constant[v'] with structurally equal value, and the plain nominal of a class whose
+        # only instance is `v`. Any other type is rejected (modulo the universal Bot/Dynamic short-circuits
+        # already applied upstream).
         def accepts_constant(self_type, other_type, mode)
           if other_type.is_a?(Type::Constant) && self_type == other_type
             Type::AcceptsResult.yes(mode: mode, reasons: "structural literal match")
+          elsif sole_instance_nominal?(self_type, other_type)
+            Type::AcceptsResult.yes(mode: mode, reasons: "#{other_type.class_name} has no instance but the literal")
           else
             Type::AcceptsResult.no(
               mode: mode,
@@ -976,6 +989,18 @@ module Rigor
           end
         end
 
+        # `true`, `false` and `nil` are the only instances of their classes, so `FalseClass` holds exactly the
+        # values `false` holds. Read apart, `Array.new(n, false)`, typed `Array[FalseClass]` through the
+        # `[T] (Integer, T)` binding, failed a declared `-> Array[bool]` and fired `def.return-type-mismatch` on
+        # correct code.
+        SOLE_INSTANCE_CLASSES = { true => "TrueClass", false => "FalseClass", nil => "NilClass" }.freeze
+        private_constant :SOLE_INSTANCE_CLASSES
+
+        def sole_instance_nominal?(constant, other_type)
+          other_type.is_a?(Type::Nominal) && other_type.type_args.empty? &&
+            SOLE_INSTANCE_CLASSES.key?(constant.value) && SOLE_INSTANCE_CLASSES[constant.value] == other_type.class_name
+        end
+
         # Tuple[A1..An] accepts:
         # - Tuple[B1..Bn] when arities match and each Ai accepts Bi (covariant per-position).
         # - Anything else: no (we cannot prove the arity from a generic nominal alone).

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

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require "yaml"
+require_relative "method_catalog"
+
+module Rigor
+  module Inference
+    module Builtins
+      # Issue #1740 — which instance methods CRuby itself defines on a core class or module, read from the offline
+      # catalogues under `data/builtins/ruby_core/` (`tool/extract_builtin_catalog.rb` records each `rb_define_method`
+      # and prelude `def` of an `Init_*` function on the class it names, aliases included). A registration inside an
+      # `#if 0` block CRuby keeps for RDoc carries `rdoc_only: true` and is left out: `random.c`'s registers
+      # `Random#seed` on `Random`, though it runs on `Random::Base`.
+      # `spec/rigor/inference/builtins/c_ruby_definers_spec.rb` checks every listed method the running Ruby has
+      # against its runtime owner. RBS is not that record: core RBS redeclares some inherited methods on a subclass
+      # (`Integer#quo` and `File#to_path`, whose CRuby owners are `Numeric` and `IO`), and declares a few CRuby no
+      # longer defines (`Process::Status#&`). A class no catalogue covers answers false, as does a method its
+      # catalogue does not list: the caller reads both as "not proven". The catalogue is one CRuby snapshot.
+      #
+      # Issue #1752 — the singleton side reads the catalogue's `singleton_methods` (each `rb_define_singleton_method`
+      # on the class), the record that `Integer.sqrt` is CRuby's own method of `Integer`'s singleton class.
+      module CRubyDefiners
+        module_function
+
+        # Does the catalogue prove CRuby defines `method_name` on `class_name` itself?
+        def defines?(class_name, method_name)
+          names = INDEX[class_name.to_s.delete_prefix("::")]
+          !names.nil? && names.include?(method_name.to_s)
+        end
+
+        # Does the catalogue prove CRuby defines `method_name` on `class_name`'s singleton class itself?
+        def singleton_defines?(class_name, method_name)
+          names = SINGLETON_INDEX[class_name.to_s.delete_prefix("::")]
+          !names.nil? && names.include?(method_name.to_s)
+        end
+
+        # `{class name => Set[method name]}` from each catalogued class's instance methods and aliases, or from its
+        # `singleton_methods` when `side` is `:singleton`.
+        def build_index(side = :instance)
+          index = Hash.new { |hash, key| hash[key] = Set.new }
+          MethodCatalog.topic_paths.each do |path|
+            data = YAML.safe_load_file(path, permitted_classes: [Symbol])
+            classes = data.is_a?(Hash) ? data["classes"] : nil
+            next unless classes.is_a?(Hash)
+
+            classes.each do |name, klass|
+              next if klass["rdoc_only"]
+
+              merge_names(index[name], klass, side)
+            end
+          end
+          Ractor.make_shareable(index.to_h { |name, names| [name, names.freeze] })
+        rescue Psych::SyntaxError, SystemCallError
+          Ractor.make_shareable({})
+        end
+
+        def merge_names(names, klass, side)
+          return names.merge(defined_names(klass["singleton_methods"])) if side == :singleton
+
+          names.merge(defined_names(klass["instance_methods"]))
+          names.merge(defined_names(klass["aliases"]))
+        end
+
+        # The names of `entries` CRuby defines at runtime: one the catalogue marks `rdoc_only` was registered only for
+        # RDoc, inside an `#if 0` block.
+        def defined_names(entries)
+          return [] unless entries.is_a?(Hash)
+
+          entries.filter_map { |method, entry| method unless entry.is_a?(Hash) && entry["rdoc_only"] }
+        end
+
+        INDEX = build_index
+        SINGLETON_INDEX = build_index(:singleton)
+        private_constant :INDEX, :SINGLETON_INDEX
+      end
+    end
+  end
+end

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

@@ -48,6 +48,9 @@ module Rigor
           new(path: File.join(DATA_ROOT, "#{topic}.yml"), mutating_selectors: mutating_selectors)
         end
 
+        # Every catalogue file under {DATA_ROOT}, in a stable order.
+        def self.topic_paths = Dir[File.join(DATA_ROOT, "*.yml")]
+
         def initialize(path:, mutating_selectors: {})
           @path = path
           @mutating_selectors = mutating_selectors.transform_values(&:freeze).freeze

data/lib/rigor/inference/captured_locals.rb

@@ -310,23 +310,63 @@ module Rigor
 
       # The mutation sites under `body` whose reads name a variable {.captured_target?} accepts, keyed by name.
       # The block yields the names the enclosing construct introduces, asked only when a local site is found.
+      #
+      # A site whose receiver is a body local that aliases a capture (`l2 = log; l2 << e`) mutates that capture's
+      # object, so it is attributed to the capture as well ({.aliased_captures}): left out, the next iteration
+      # read `log` at its entry `[]` and `[1, 2].inject(0) { |a, e| r = a + log.size; l2 = log; l2 << e; r }`
+      # folded to `0` where Ruby answers `1` (issue #1332).
       def body_mutation_sites(body, base_scope, non_locals, &)
         sites = nil
         evaluator = nil
+        aliases = nil
         Source::NodeWalker.each_with_ancestors(body) do |descendant, ancestors|
           # A callee is resolved in the call-site scope, as the straight-line callee floor resolves it.
           site = mutation_site(descendant) { evaluator ||= StatementEvaluator.new(scope: base_scope) }
           next if site.nil?
 
           site_reads(site).each do |read|
-            next unless captured_target?(read, ancestors, base_scope, non_locals, &)
-
-            ((sites ||= {})[read.name] ||= []) << site
+            targets = captured_target?(read, ancestors, base_scope, non_locals, &) ? [read] : []
+            if read.is_a?(Prism::LocalVariableReadNode)
+              aliases ||= local_aliases(body)
+              targets.concat(aliased_captures(read.name, aliases, base_scope, non_locals, Set.new, &))
+            end
+            targets.each { |target| ((sites ||= {})[target.name] ||= []) << site }
           end
         end
         sites || NO_SITES
       end
 
+      # `{ name => [[read, ancestors], ...] }`: every variable read a local write under `body` may store
+      # ({ReceiverAlias.candidates} of its value), with the ancestors {.captured_target?} resolves it against.
+      def local_aliases(body)
+        aliases = {}
+        Source::NodeWalker.each_with_ancestors(body) do |node, ancestors|
+          next unless node.is_a?(Prism::LocalVariableWriteNode) || node.is_a?(Prism::LocalVariableOrWriteNode)
+
+          ReceiverAlias.candidates(node.value).each do |read|
+            (aliases[node.name] ||= []) << [read, ancestors + [node]]
+          end
+        end
+        aliases
+      end
+
+      # The captured reads the local `name` may alias, followed through local-to-local copies (`l3 = l2 = log`).
+      # It over-approximates — a write in any branch, or in a nested scope reusing the name, counts — which only
+      # widens a capture's binding.
+      def aliased_captures(name, aliases, base_scope, non_locals, visited, &)
+        return [] unless visited.add?(name)
+
+        aliases.fetch(name, NO_NAMES).flat_map do |read, ancestors|
+          if captured_target?(read, ancestors, base_scope, non_locals, &)
+            [read]
+          elsif read.is_a?(Prism::LocalVariableReadNode)
+            aliased_captures(read.name, aliases, base_scope, non_locals, visited, &)
+          else
+            NO_NAMES
+          end
+        end
+      end
+
       # The mutation site `node` is — the node itself, or a {UnknownStoreWidening::CalleeStore} for a self-call
       # whose callee content-mutates a local it is passed — or nil. A self-call is resolved by the
       # `StatementEvaluator` the block yields, which the caller builds only when one is needed. A mutator name

data/lib/rigor/inference/def_node_resolver.rb

@@ -33,7 +33,7 @@ module Rigor
       # ({.rehydrated_nesting}).
       def self.with_run
         previous = Thread.current[MEMO_KEY]
-        Thread.current[MEMO_KEY] = { nodes: {}, indexes: {}, nestings: {}.compare_by_identity }
+        Thread.current[MEMO_KEY] = { nodes: {}, indexes: {}, nestings: {}.compare_by_identity, refinement_queries: {} }
         yield
       ensure
         Thread.current[MEMO_KEY] = previous
@@ -113,6 +113,28 @@ module Rigor
       end
       private_class_method :record_nesting
 
+      # Issue #1664 — the {InEffectRefinements} over `path`'s own parse, once a run, or nil when the file cannot be
+      # read: the typed refined arm reads another file's refine body through it. The bodies' `Module.nesting`
+      # is recorded as a handle's is, so the re-typed body reads its constants where it is written.
+      def self.refinement_query(path)
+        memo = Thread.current[MEMO_KEY]
+        return build_refinement_query(path, nil) if memo.nil?
+
+        queries = memo[:refinement_queries]
+        return queries[path] if queries.key?(path)
+
+        queries[path] = build_refinement_query(path, memo)
+      end
+
+      def self.build_refinement_query(path, memo)
+        query = InEffectRefinements.new(Prism.parse(File.read(path)).value)
+        query.refine_def_nestings.each { |node, nesting| record_nesting(memo, node, nesting) } if memo
+        query
+      rescue StandardError
+        nil
+      end
+      private_class_method :build_refinement_query
+
       # Finds the node for `handle` using a per-file `{node_id => DefNode}` + `{name => DefNode}` index cache.
       def self.locate(handle, index_cache)
         index = index_cache[handle.path] ||= build_file_index(handle.path)