rigortype 0.4.0 → 0.4.2

data/lib/rigor/analysis/run_stats.rb

@@ -95,12 +95,12 @@ module Rigor
       # with any of the signature path prefixes (after expansion to absolute paths); `bundled` is the
       # remainder.
       def self.partition_classes(class_decl_paths:, signature_paths:)
-        prefixes = Array(signature_paths).map { |p| File.expand_path(p.to_s) }
+        prefixes = Array(signature_paths).map { |p| File.absolute_path(p.to_s) }
         return [0, class_decl_paths.size] if prefixes.empty?
 
         project = 0
         class_decl_paths.each_value do |path|
-          expanded = File.expand_path(path)
+          expanded = File.absolute_path(path)
           project += 1 if prefixes.any? { |prefix| expanded.start_with?("#{prefix}/") || expanded == prefix }
         end
         [project, class_decl_paths.size - project]

data/lib/rigor/analysis/runner/diagnostic_aggregator.rb

@@ -36,6 +36,8 @@ module Rigor
         #   that stood down against a colliding generic arity (#610), as
         #   `[path, class_name, existing_arity, incoming_arity, existing_file]` tuples. Defaults to none so
         #   a caller that snapshots nothing of the kind need not say so.
+        # @param vendored_standdowns_snapshot — issue #1713 — reader returning what each required-feature-gated
+        #   vendored directory left out (`Environment::RbsLoader#vendored_standdowns`). Defaults to none.
         # @param env_build_failure_snapshot — reader returning the total RBS env-build failure tuple
         #   (`[error_class, first_error_line, conflicting_buffer_names]`) or nil when the env built.
         # @param definition_build_failures_snapshot — issue #696 — reader returning the per-class
@@ -55,7 +57,7 @@ module Rigor
                        quarantined_signatures_snapshot:, env_build_failure_snapshot:,
                        definition_build_failures_snapshot:, hkt_scan_failure_snapshot:,
                        conformance_results_snapshot:, signature_standdowns_snapshot: -> { [] },
-                       pooled_run_disclosures: -> { [] })
+                       vendored_standdowns_snapshot: -> { [] }, pooled_run_disclosures: -> { [] })
           @configuration = configuration
           @rbs_extended_reporter = rbs_extended_reporter
           @boundary_cross_reporter = boundary_cross_reporter
@@ -68,6 +70,7 @@ module Rigor
           @synthesized_namespaces_snapshot_reader = synthesized_namespaces_snapshot
           @quarantined_signatures_snapshot_reader = quarantined_signatures_snapshot
           @signature_standdowns_snapshot_reader = signature_standdowns_snapshot
+          @vendored_standdowns_snapshot_reader = vendored_standdowns_snapshot
           @env_build_failure_snapshot_reader = env_build_failure_snapshot
           @definition_build_failures_snapshot_reader = definition_build_failures_snapshot
           @hkt_scan_failure_snapshot_reader = hkt_scan_failure_snapshot
@@ -437,11 +440,23 @@ module Rigor
           standdowns.map { |entry| build_rbs_plugin_signature_stood_down_diagnostic(entry) }
         end
 
-        # The two `:info` notices that close the `rbs.coverage.*` ladder, in this order: the namespace
-        # synthesis first, then the stand-down (#610) — the outcome that AVOIDED a definition-build failure
-        # and so the quietest row on it. One method so the runner's assembly reads them as one slot.
+        # Issue #1713 — the other outcome that avoided a definition-build failure: a required-feature-gated
+        # vendored directory (`data/vendored_gem_sigs/prime/`) left out what another signature source already
+        # declares — a member, a whole type, or, when nothing narrower built, the directory. One `:info` per
+        # directory, naming the declarations that stood down and the files that displaced them.
+        def rbs_vendored_signature_stood_down_diagnostics
+          standdowns = vendored_standdowns_snapshot
+          return [] if standdowns.nil? || standdowns.empty?
+
+          standdowns.map { |entry| build_rbs_vendored_signature_stood_down_diagnostic(entry) }
+        end
+
+        # The `:info` notices that close the `rbs.coverage.*` ladder, in this order: the namespace synthesis
+        # first, then the stand-downs (#610, #1713) — the outcomes that AVOIDED a definition-build failure and so
+        # the quietest rows on it. One method so the runner's assembly reads them as one slot.
         def rbs_coverage_notice_diagnostics
-          rbs_synthesized_namespace_diagnostics + rbs_plugin_signature_stood_down_diagnostics
+          rbs_synthesized_namespace_diagnostics + rbs_plugin_signature_stood_down_diagnostics +
+            rbs_vendored_signature_stood_down_diagnostics
         end
 
         # Maps the per-run `rigor:v1:conforms-to` scan results into diagnostics (spec: `rbs-extended.md` §
@@ -769,6 +784,69 @@ module Rigor
           )
         end
 
+        def build_rbs_vendored_signature_stood_down_diagnostic(entry)
+          dir, declarations, whole = entry
+          Diagnostic.new(
+            path: ".rigor.yml",
+            line: 1,
+            column: 1,
+            message: vendored_standdown_message(dir, declarations, whole),
+            severity: :info,
+            rule: "rbs.coverage.vendored-signature-stood-down",
+            source_family: :builtin
+          )
+        end
+
+        def vendored_standdown_message(dir, declarations, whole)
+          subject = "Rigor's vendored `#{dir}` signatures (loaded because the project requires `#{dir}` or lists " \
+                    "it under `libraries:`)"
+          return vendored_whole_standdown_message(subject, dir, declarations) if whole
+
+          vendored_partial_standdown_message(subject, declarations)
+        end
+
+        # One sentence per kind of stand-down present ({Environment::GatedSignaturePlan.standdowns}' reasons).
+        VENDORED_STANDDOWN_SENTENCES = {
+          "member" => "left out %<count>d method declaration(s) another signature source also makes, since two " \
+                      "declarations of one method fail the class's definition build, and uses the other " \
+                      "source's: %<list>s.",
+          "type" => "stood %<count>d type(s) down whole, keeping only the types nested in them, because another " \
+                    "source declares each with a different kind (class or module) or generic arity, or the type " \
+                    "failed to build beside that source's declaration: %<list>s.",
+          "open" => "kept %<count>d type(s) without their superclass, because each failed to build beside the " \
+                    "other signatures although no other source declares it; calls they no longer answer read " \
+                    "untyped rather than undefined: %<list>s."
+        }.freeze
+        private_constant :VENDORED_STANDDOWN_SENTENCES
+
+        def vendored_partial_standdown_message(subject, declarations)
+          sentences = VENDORED_STANDDOWN_SENTENCES.filter_map do |reason, template|
+            group = declarations.select { |entry| (entry[2] || "member") == reason }
+            next if group.empty?
+
+            format(template, count: group.size, list: sampled(vendored_standdown_labels(group), 5))
+          end
+          "#{subject} loaded without some of their declarations. Rigor #{sentences.join(' Rigor ')} The rest of the " \
+            "vendored signatures still load. Nothing to fix unless the other declaration is an outdated copy; " \
+            "removing it brings the vendored one back."
+        end
+
+        def vendored_whole_standdown_message(subject, dir, declarations)
+          labels = vendored_standdown_labels(declarations)
+          clashes = labels.empty? ? "" : " Declarations it clashed with: #{sampled(labels, 5)}."
+          "#{subject} stood down " \
+            "entirely: a type they declare failed to build beside the other signature sources even with the " \
+            "clashing declarations left out, so calls into `#{dir}`'s API resolve only against what those " \
+            "sources declare.#{clashes}"
+        end
+
+        def vendored_standdown_labels(declarations)
+          declarations.map do |declaration, cause_file|
+            cause = cause_file.nil? ? "" : " (#{relative_signature_path(cause_file.to_s)})"
+            "`#{declaration}`#{cause}"
+          end
+        end
+
         def displacing_source_phrase(existing_file)
           return "another loaded signature source" if existing_file.nil?
 
@@ -965,7 +1043,7 @@ module Rigor
 
         # Issue #959 — surfaces the {Plugin::IoBoundary} refusal history each loaded plugin accumulated over
         # the whole run (prepare AND every per-file call: `#io_boundary` is memoised per plugin instance, so
-        # one boundary sees both). `TrustPolicy#allow_read?` stays `File.expand_path`-only per ADR-2 — a
+        # one boundary sees both). `TrustPolicy#allow_read?` stays `File.absolute_path`-only per ADR-2 — a
         # project rooted under a symlink (macOS' `/tmp` → `/private/tmp` is the common case) can have every
         # plugin read fall outside its own read roots with nothing said about it. One `:info` row per plugin
         # that hit this, never one per path, naming the count and the first path so the row stays legible on
@@ -1196,6 +1274,10 @@ module Rigor
           @signature_standdowns_snapshot_reader.call
         end
 
+        def vendored_standdowns_snapshot
+          @vendored_standdowns_snapshot_reader.call
+        end
+
         def env_build_failure_snapshot
           @env_build_failure_snapshot_reader.call
         end

data/lib/rigor/analysis/runner/pool_coordinator.rb

@@ -45,7 +45,8 @@ module Rigor
                        snapshots:, plugin_registry:, dependency_source_index:,
                        synthetic_method_index:, project_patched_methods:,
                        analyze_file:, project_scope_seed: -> { {} }, record_dependencies: false,
-                       restored_run_level_rows: nil, template_units: -> { TemplateUnits.empty })
+                       restored_run_level_rows: nil, template_units: -> { TemplateUnits.empty },
+                       feature_sources: -> { {} })
           @configuration = configuration
           @cache_store = cache_store
           @explain = explain
@@ -67,6 +68,7 @@ module Rigor
           @collected_run_disclosures = {}
           @collect_stats = collect_stats
           @buffer = buffer
+          @feature_sources = feature_sources
           @environment_override = environment_override
           @rbs_extended_reporter = rbs_extended_reporter
           @boundary_cross_reporter = boundary_cross_reporter
@@ -208,7 +210,7 @@ module Rigor
 
             env = resolve_sequential_environment(source_files: project_files)
           end
-          snapshot_project_signature_state(signature_state_environment(resolve))
+          snapshot_project_signature_state(signature_state_environment(resolve, project_files))
           snapshot_effect_annotation_carrier(
             annotation_carrier_environment(resolve, in_hand: !env.nil?)&.rbs_loader
           )
@@ -220,11 +222,21 @@ module Rigor
           record_hkt_scan_failure(hkt_scan_outcome(resolve.call))
         end
 
-        # Issue #794 — the signature-state snapshot's own gates, asked BEFORE an environment exists. Both
-        # answers are loader-free (the configuration and the plugin registry), and with neither gate open
-        # {#snapshot_project_signature_state} writes the same empty state a nil environment gives it.
-        def signature_state_environment(resolve)
-          plugin_signature_paths? || project_signature_paths? ? resolve.call : nil
+        # Issue #794 — the signature-state snapshot's own gates, asked BEFORE an environment exists. Every
+        # answer is loader-free (the configuration, the plugin registry and, issue #1713, the required-feature
+        # scan), and with no gate open {#snapshot_project_signature_state} writes the same empty state a nil
+        # environment gives it.
+        def signature_state_environment(resolve, project_files)
+          gated = plugin_signature_paths? || project_signature_paths? || vendored_features_requested?(project_files)
+          gated ? resolve.call : nil
+        end
+
+        # Issue #1713 — whether this run activates a required-feature-gated vendored directory, whose stand-down
+        # {#snapshot_project_signature_state} reports: the scan every build of this run gates on, or the
+        # feature named under `libraries:`.
+        def vendored_features_requested?(project_files)
+          features = project_files.nil? || project_files.empty? ? [] : required_features_for(project_files)
+          !Environment::RequiredFeatures.tokens(features, @configuration.libraries).empty?
         end
 
         # Issue #794 — the same, for the #441 carrier. The carrier is a filter over the loader's
@@ -287,10 +299,10 @@ module Rigor
           buffers = failure.is_a?(Array) ? failure[3] : nil
           return false if buffers.nil?
 
-          closure_paths = closure.to_set { |path| File.expand_path(path.to_s) }
+          closure_paths = closure.to_set { |path| File.absolute_path(path.to_s) }
           Array(buffers).any? do |name|
             path = virtual_buffer_path(name)
-            !path.nil? && closure_paths.include?(File.expand_path(path))
+            !path.nil? && closure_paths.include?(File.absolute_path(path))
           end
         end
 
@@ -344,6 +356,10 @@ module Rigor
           # no such plugin reads nothing off its loader here, as before.
           @snapshots.signature_standdowns =
             plugin_signature_paths? ? signature_standdowns_for(environment&.rbs_loader) : []
+          # Issue #1713 — NOT behind the `signature_paths:` gate either: what displaces a vendored declaration may
+          # be a gem's or a collection's copy. The loader answers without building its env when no gated
+          # directory is active.
+          @snapshots.vendored_standdowns = vendored_standdowns_for(environment&.rbs_loader)
           unless project_signature_paths?
             @snapshots.synthesized_namespaces = []
             @snapshots.quarantined_signatures = []
@@ -459,7 +475,22 @@ module Rigor
             **ProjectEnvironment.dependency_discovery_options(@configuration),
             synthetic_method_index: synthetic_method_index,
             project_patched_methods: project_patched_methods,
-            source_files: source_files
+            source_files: source_files,
+            required_features: required_features_for(source_files)
+          )
+        end
+
+        # Issue #1700 — the {Environment::RequiredFeatures} this run's environments gate on: the configured paths
+        # plus `source_files`, whichever files the run checks, with an editor buffer or an in-memory source read
+        # in place of its file. Taken once per file list and handed to every build (the sequential one, the
+        # pool's prewarm and each worker), so they agree and a pool does not re-read the project per worker.
+        def required_features_for(source_files)
+          key = source_files.map(&:to_s)
+          return @required_features if @required_features_key == key
+
+          @required_features_key = key
+          @required_features = Ractor.make_shareable(
+            Environment::RequiredFeatures.for_configuration(@configuration, key, sources: @feature_sources.call)
           )
         end
 
@@ -575,9 +606,10 @@ module Rigor
           # a frozen Array<String>; cheaply shareable. Issue #793 — it IS the full project now
           # (`source_files`), not the analyzed subset this comment always described.
           shareable_source_files = source_files.map { |path| path.to_s.dup.freeze }.freeze
+          features = required_features_for(source_files)
 
           pool = Array.new(@workers) do
-            Ractor.new(configuration, cache_root, blueprints, explain, shareable_source_files, locked_gems) do |configuration, cache_root, blueprints, explain, shareable_source_files, locked_gems| # rubocop:disable Layout/LineLength
+            Ractor.new(configuration, cache_root, blueprints, explain, shareable_source_files, locked_gems, features) do |configuration, cache_root, blueprints, explain, shareable_source_files, locked_gems, features| # rubocop:disable Layout/LineLength
               cache_store = cache_root ? Rigor::Cache::Store.new(root: cache_root) : nil
               session = Rigor::Analysis::WorkerSession.new(
                 configuration: configuration,
@@ -585,7 +617,8 @@ module Rigor
                 plugin_blueprints: blueprints,
                 explain: explain,
                 source_files: shareable_source_files,
-                locked_gems: locked_gems
+                locked_gems: locked_gems,
+                required_features: features
               )
               main = Ractor.main
               main.send([:prepare, session.prepare_diagnostics])
@@ -713,7 +746,8 @@ module Rigor
             project_scope_seed: project_scope_seed,
             source_files: source_files,
             record_dependencies: @record_dependencies,
-            template_units: template_units
+            template_units: template_units,
+            required_features: required_features_for(source_files)
           )
           # Force the full RBS load on the parent so children copy-on-write inherit a warm Environment
           # rather than each rebuilding it after the fork.
@@ -890,6 +924,7 @@ module Rigor
             plugin_registry: plugin_registry,
             source_files: source_files,
             locked_gems: locked_gems,
+            required_features: required_features_for(source_files),
             **ProjectEnvironment.dependency_discovery_options(@configuration)
           )
           warm_env.rbs_loader&.prewarm
@@ -1094,6 +1129,10 @@ module Rigor
           loader.signature_standdowns
         end
 
+        def vendored_standdowns_for(loader)
+          loader.respond_to?(:vendored_standdowns) ? loader.vendored_standdowns : []
+        end
+
         def plugin_registry
           @plugin_registry_reader.call
         end

data/lib/rigor/analysis/runner/project_pre_passes.rb

@@ -23,7 +23,7 @@ module Rigor
       # ivar surface, preserving the exact assignment order and timing the inline body had. The `pool_mode`
       # predicate is injected (it keys on `@workers` / `@buffer`, owned by the Runner) so this collaborator
       # never calls back into it.
-      class ProjectPrePasses
+      class ProjectPrePasses # rubocop:disable Metrics/ClassLength -- the Discovery slots are one declaration per table
         # Frozen bundle of the EAGER (env-input) project-wide state the pre-passes produce — the slots whose
         # products feed the RBS environment build. Mirrors the env-input ivars `apply_pre_passes_result`
         # sets on the {Runner}. The cross-file discovery tables live in the separate {Discovery} bundle
@@ -53,12 +53,13 @@ module Rigor
         # consumes them and so never pays the double parse (see {#discover} + `Runner#ensure_project_discovery`).
         # The slot names mirror the discovery half of {Result} exactly.
         Discovery = Data.define(
-          :discovered_classes, :discovered_def_nodes, :discovered_def_nestings,
-          :discovered_singleton_def_nodes, :discovered_def_sources, :discovered_singleton_def_sources,
-          :discovered_superclasses, :discovered_header_nestings, :discovered_includes, :discovered_prepends,
-          :discovered_extends, :discovered_class_sources, :constant_values, :constant_sources, :constant_writes,
+          :discovered_classes, :discovered_def_nodes, :discovered_def_nestings, :discovered_singleton_def_nodes,
+          :discovered_def_sources, :discovered_singleton_def_sources, :discovered_superclasses,
+          :discovered_header_nestings, :discovered_includes, :discovered_prepends, :discovered_extends,
+          :unpositioned_mixins, :discovered_class_sources, :constant_values, :constant_sources, :constant_writes,
           :discovered_method_visibilities, :discovered_methods, :discovered_parameter_envelopes, :data_member_layouts,
-          :struct_member_layouts, :discovered_deferred_ranges, :discovered_refinements, :discovered_global_write_census
+          :struct_member_layouts, :discovered_deferred_ranges, :discovered_refinements, :siblings,
+          :discovered_global_write_census
         )
 
         # Internal: drives every EAGER project-wide pre-pass — the ones whose products feed the RBS
@@ -172,7 +173,7 @@ module Rigor
             discovered_prepends: def_index.fetch(:prepends),
             # Issue #898 — the singleton-side mixin table, kept beside the instance-side one so a class
             # object's `extend`s reach `Narrowing` from a sibling file the way its `include`s already do.
-            discovered_extends: def_index.fetch(:extends),
+            discovered_extends: def_index.fetch(:extends), unpositioned_mixins: def_index.fetch(:unpositioned_mixins),
             discovered_class_sources: def_index.fetch(:class_sources),
             # Issue #644 — the cross-file value-constant publication table and its write attribution.
             constant_values: def_index.fetch(:constant_values), constant_sources: def_index.fetch(:constant_sources),
@@ -186,7 +187,8 @@ module Rigor
             # `*_def_shadows_call?` predicates order `sig`-shadowing defs against.
             discovered_deferred_ranges: def_index.fetch(:deferred_ranges),
             discovered_refinements: def_index.fetch(:refinements), # Issue #1120
-            discovered_global_write_census: def_index.fetch(:global_write_census) # Issue #1367
+            # Issue #1367 — the census; ADR-119 WD1 — `{sibling name => table}` for `DiscoveryIndex::SIBLINGS`.
+            discovered_global_write_census: def_index.fetch(:global_write_census), siblings: def_index.fetch(:siblings)
           )
         end
 
@@ -233,13 +235,19 @@ module Rigor
         # {Rigor::Plugin::Registry} WITHOUT the synthetic-method / dependency-source / pre-eval scanners. The
         # incremental fact-surface fingerprint probe ({Analysis::PluginFactFingerprint}) uses this to read the
         # ADR-9 fact store + drive the ADR-60 producers without paying for the full pre-pass or building the RBS
-        # environment. `prepare` runs unconditionally here — the probe is always sequential (its `pool_mode?`
+        # environment. `prepare` runs whatever the pool mode — the probe is always sequential (its `pool_mode?`
         # reader returns false), so the pool-mode skip in {#run} does not apply. Prepare diagnostics are
         # discarded: a plugin that raises in `#prepare` publishes no facts, so its surface is simply absent from
         # the fingerprint, exactly as it would be absent from analysis.
-        def prepared_registry
+        #
+        # Issue #1536 — `prepare: false` loads the plugins without running `#prepare`, for a caller that reads
+        # only what a manifest declares: the incremental session reads each plugin's `source_rbs_synthesizer`
+        # before its recheck runner exists. A synthesizer's output is a function of the file, the plugin's
+        # config and the engine — the key its `Cache::Store` entry already rests on — so `#prepare` has
+        # nothing to add to it, and skipping it keeps that read off every plugin's prepare-time scans.
+        def prepared_registry(prepare: true)
           registry = load_plugins
-          plugin_prepare_diagnostics(registry) unless registry.empty?
+          plugin_prepare_diagnostics(registry) if prepare && !registry.empty?
           registry
         end
 
@@ -288,12 +296,12 @@ module Rigor
         def build_trust_policy
           trusted_gems = @configuration.plugins.map { |entry| trusted_gem_name(entry) }.uniq
           roots = [Dir.pwd]
-          Array(@configuration.signature_paths).each { |sp| roots << File.expand_path(sp) }
+          Array(@configuration.signature_paths).each { |sp| roots << File.absolute_path(sp) }
           trusted_gems.each do |gem_name|
             path = trusted_gem_root(gem_name)
             roots << path if path
           end
-          @configuration.plugins_io_allowed_paths.each { |p| roots << File.expand_path(p) }
+          @configuration.plugins_io_allowed_paths.each { |p| roots << File.absolute_path(p) }
 
           Plugin::TrustPolicy.new(
             trusted_gems: trusted_gems,

data/lib/rigor/analysis/runner/run_snapshots.rb

@@ -16,7 +16,8 @@ module Rigor
       # back-reference cycle.
       class RunSnapshots
         attr_accessor :class_decl_paths, :signature_paths,
-                      :synthesized_namespaces, :quarantined_signatures, :signature_standdowns, :conformance_results,
+                      :synthesized_namespaces, :quarantined_signatures, :signature_standdowns, :vendored_standdowns,
+                      :conformance_results,
                       :env_build_failure, :definition_build_failures, :hkt_scan_failure,
                       :effect_annotation_carrier
 
@@ -32,12 +33,15 @@ module Rigor
         # `signature_standdowns` (#610) is the quarantine slot's twin for the plugin-contributed files that
         # stood down against a colliding generic arity: a list, assigned once from the loader as
         # `quarantined_signatures` is, and derived from the final env so a cache HIT carries it too.
+        # `vendored_standdowns` (#1713) is the same shape of slot for what a required-feature-gated vendored
+        # directory left out because another signature source declares it.
         def initialize
           @class_decl_paths = {}.freeze
           @signature_paths = [].freeze
           @synthesized_namespaces = [].freeze
           @quarantined_signatures = [].freeze
           @signature_standdowns = [].freeze
+          @vendored_standdowns = [].freeze
           @conformance_results = [].freeze
           @env_build_failure = nil
           @definition_build_failures = [].freeze
@@ -53,6 +57,7 @@ module Rigor
           @synthesized_namespaces = []
           @quarantined_signatures = []
           @signature_standdowns = []
+          @vendored_standdowns = []
           @conformance_results = []
           @env_build_failure = nil
           @definition_build_failures = []