rigortype 0.4.5 → 0.4.6

data/lib/rigor/plugin/manifest.rb

@@ -56,7 +56,7 @@ module Rigor
                   :hkt_registrations, :hkt_definitions, :signature_paths, :protocol_contracts,
                   :source_rbs_synthesizer, :additional_initializers,
                   :effect_root, :effect_labels, :effect_attributions, :effect_edges, :effect_entry_points,
-                  :effect_ancestry
+                  :effect_ancestry, :per_invocation_classes, :per_invocation_non_action_macros
 
       # #392 — the project-relative globs whose files this plugin compiles into {TemplateUnit}s. Purely a
       # CLAIM: the engine globs these, reads each match's bytes and offers them to
@@ -74,7 +74,8 @@ module Rigor
         hkt_registrations: [], hkt_definitions: [], signature_paths: [], protocol_contracts: [],
         source_rbs_synthesizer: nil, additional_initializers: [],
         effect_root: nil, effect_labels: [], effect_attributions: [], effect_edges: [],
-        effect_entry_points: [], effect_ancestry: [], template_globs: []
+        effect_entry_points: [], effect_ancestry: [], template_globs: [], per_invocation_classes: [],
+        per_invocation_non_action_macros: []
       )
         validate_id!(id)
         validate_version!(version)
@@ -109,6 +110,7 @@ module Rigor
         assign_additional_initializers(additional_initializers)
         assign_effect_fields(effect_root, effect_labels, effect_attributions, effect_edges,
                              effect_entry_points, effect_ancestry, template_globs)
+        assign_per_invocation_classes(per_invocation_classes, per_invocation_non_action_macros)
         freeze
       end
 
@@ -202,6 +204,28 @@ module Rigor
         @template_globs = globs.map { |glob| glob.to_s.dup.freeze }.uniq.freeze
       end
       private :assign_template_globs
+
+      # ADR-125 — `per_invocation_classes:` names the framework classes whose every instance serves exactly one
+      # entry point, so ivar writes in two distinct entry points of a descendant are never live together.
+      # `per_invocation_non_action_macros:` names the class-body macros whose Symbol, String or inline-`def`
+      # arguments name a public method that is NOT an entry point (`before_action :load`, `helper_method
+      # :current_user`); they apply to this manifest's own `per_invocation_classes:`, so a list without classes
+      # is refused. Validated and assigned in one call, because `#initialize` is at its line budget.
+      def assign_per_invocation_classes(names, macros)
+        validate_array_of!("per_invocation_classes", names, "non-empty String") do |name|
+          name.is_a?(String) && !name.empty?
+        end
+        validate_array_of!("per_invocation_non_action_macros", macros, "Symbol/non-empty String") do |macro|
+          macro.is_a?(Symbol) || (macro.is_a?(String) && !macro.empty?)
+        end
+        if names.empty? && !macros.empty?
+          raise ArgumentError, "per_invocation_non_action_macros needs per_invocation_classes to apply to"
+        end
+
+        @per_invocation_classes = names.map { |name| name.to_s.delete_prefix("::").dup.freeze }.uniq.freeze
+        @per_invocation_non_action_macros = macros.map(&:to_sym).uniq.freeze
+      end
+      private :assign_per_invocation_classes
       # rubocop:enable Metrics/ParameterLists, Metrics/AbcSize
 
       public
@@ -258,7 +282,9 @@ module Rigor
           "effect_edges" => effect_edges.map(&:to_h),
           "effect_entry_points" => effect_entry_points.map(&:to_h),
           "effect_ancestry" => effect_ancestry.map(&:to_h),
-          "template_globs" => template_globs
+          "template_globs" => template_globs,
+          "per_invocation_classes" => per_invocation_classes,
+          "per_invocation_non_action_macros" => per_invocation_non_action_macros.map(&:to_s)
         }
       end
 

data/lib/rigor/plugin/registry.rb

@@ -397,6 +397,28 @@ module Rigor
         @rbs_complete_extends_set.include?(class_name.to_s)
       end
 
+      # ADR-125 — the aggregate class names declared across loaded plugins as per-invocation (manifest
+      # `per_invocation_classes:`): each instance of a descendant serves exactly one public-method entry point.
+      # `per_invocation_class?` is the exact-name membership predicate; `def.ivar-write-mismatch` walks a
+      # class's ancestry and asks it of each ancestor.
+      attr_reader :per_invocation_classes
+
+      def per_invocation_class?(class_name)
+        return false if class_name.nil?
+
+        @per_invocation_classes_set.include?(class_name.to_s.delete_prefix("::"))
+      end
+
+      # ADR-125 — the macros whose arguments name a non-entry-point method on a descendant of the declared
+      # per-invocation class `class_name`: the union of `per_invocation_non_action_macros:` over the manifests
+      # that declare that class. An empty Set for a class no manifest declares.
+      def per_invocation_non_action_macros(class_name)
+        @per_invocation_macros.fetch(class_name.to_s.delete_prefix("::"), EMPTY_MACROS)
+      end
+
+      EMPTY_MACROS = Set.new.freeze
+      private_constant :EMPTY_MACROS
+
       # ADR-28 — flat, ordered list of every loaded plugin's path-scoped method-protocol contracts, in
       # plugin registration order. Read from each plugin's `#protocol_contracts` (which the manifest backs
       # by default but a plugin MAY override to fold in per-project config). Consumed by
@@ -465,12 +487,28 @@ module Rigor
         @rbs_complete_ancestors_set = @rbs_complete_ancestors.to_set.freeze
         @rbs_complete_extends = aggregate_class_names(manifests, :rbs_complete_extends)
         @rbs_complete_extends_set = @rbs_complete_extends.to_set.freeze
+        @per_invocation_classes = aggregate_class_names(manifests, :per_invocation_classes)
+        @per_invocation_classes_set = @per_invocation_classes.to_set.freeze
+        @per_invocation_macros = compile_per_invocation_macros(manifests)
         @type_node_resolvers = manifests.flat_map { |m| m&.type_node_resolvers || [] }.freeze
         @protocol_contracts = @plugins.flat_map { |p| safe_protocol_contracts(p) }.freeze
         @contracts_by_path = {}
         @effect_memo = {}
       end
 
+      # ADR-125 — declared class name => frozen Set of the non-action macros its declaring manifests list.
+      def compile_per_invocation_macros(manifests)
+        table = Hash.new { |hash, key| hash[key] = Set.new }
+        manifests.each do |manifest|
+          next if manifest.nil?
+
+          manifest.per_invocation_classes.each do |name|
+            table[name].merge(manifest.per_invocation_non_action_macros)
+          end
+        end
+        table.to_h { |name, macros| [name, macros.freeze] }.freeze
+      end
+
       # The shared shape of `open_receivers:` / `rbs_complete_ancestors:` — a flat uniq'd class-name list
       # aggregated across manifests, each entry normalised to String.
       def aggregate_class_names(manifests, field)

data/lib/rigor/protection/discovery_seed.rb

@@ -3,6 +3,9 @@
 require_relative "../inference/parameter_inference_collector"
 require_relative "../inference/scope_indexer"
 require_relative "../inference/project_seed_tables"
+require_relative "../cache/incremental_snapshot"
+require_relative "../analysis/path_expansion"
+require_relative "../analysis/buffer_binding"
 
 module Rigor
   module Protection
@@ -73,12 +76,64 @@ module Rigor
       # @param paths — the measured file set, in the same order {#bundles} was built from.
       # @param bundles — that bundle set.
       # @param buffer — the mutant binding (logical path → mutant bytes).
+      # @param constant_sources — ADR-124 — also carry the per-name writer paths (`constant_sources`), which a
+      #   `prebuilt:` runner needs to retract a `pre_eval:` constant another file also assigns (#663).
       # @return frozen seed tables.
-      def tables_for_buffer(paths:, bundles:, buffer:)
+      def tables_for_buffer(paths:, bundles:, buffer:, constant_sources: false)
         index = Inference::ScopeIndexer.discovered_project_index_incremental(
           paths, seed_bundles: bundles, buffer: buffer
         )
-        seed_tables(index).freeze
+        tables = seed_tables(index)
+        sources = index.fetch(:def_index).fetch(:constant_sources)
+        tables = tables.merge(constant_sources: sources) if constant_sources && !sources.empty?
+        tables.freeze
+      end
+
+      # Issue #512 — the seed a one-shot probe (`rigor type-of`) can afford: the cross-file discovery tables for
+      # the configured paths, folded from the per-file bundles a prior `rigor check --incremental` left in the
+      # persistent snapshot, with `buffer`'s file (and any file whose bytes moved since) re-walked. A probe has
+      # no business re-parsing the project — that is what made the first attempt cost twice a single-file probe —
+      # so when there is no reusable snapshot this answers nil and the caller keeps its single-file scope. It
+      # never writes the snapshot.
+      #
+      # The snapshot is reused only under the fingerprint a bare `rigor check --incremental` writes (roots = the
+      # configured paths, the plain run mode): any other fingerprint, a different engine, configuration,
+      # lockfile or `sig/` included, is a miss.
+      #
+      # @param configuration — the probe's loaded configuration.
+      # @param buffer — the editor binding, or nil.
+      # @return frozen seed tables, or nil when the snapshot cannot seed this project.
+      def from_snapshot(configuration:, buffer: nil)
+        paths = Analysis::PathExpansion.configured_files(configuration)
+        return nil if paths.empty?
+
+        bundles = snapshot_bundles(configuration)
+        return nil if bundles.nil? || bundles.empty?
+
+        tables_for_buffer(paths: respell_for_buffer(paths, buffer), bundles: bundles, buffer: buffer,
+                          constant_sources: true)
+      end
+
+      # The configured file list with the entry that reaches `buffer`'s file respelled as the buffer's logical
+      # path: the binding substitutes bytes only for a path spelled exactly as its logical path, while the
+      # configured paths may be relative or reach the file through a symlink. `real_paths` is the memoised
+      # `BufferBinding.real_path` of each entry when the caller keeps one.
+      def respell_for_buffer(paths, buffer, real_paths: nil)
+        return paths if buffer.nil?
+
+        real = Analysis::BufferBinding.real_path(buffer.logical_path)
+        paths.each_with_index.map do |path, index|
+          entry_real = real_paths ? real_paths[index] : Analysis::BufferBinding.real_path(path)
+          entry_real == real ? buffer.logical_path : path
+        end
+      end
+
+      def snapshot_bundles(configuration)
+        fingerprint = Cache::IncrementalSnapshot.fingerprint(configuration: configuration, roots: configuration.paths)
+        return nil if fingerprint.nil?
+
+        loaded = Cache::IncrementalSnapshot.new(root: configuration.cache_path).load_any(fingerprints: [fingerprint])
+        loaded&.last&.seed_bundles
       end
 
       # The whole-project discovery tables, from the single-walk combined pass (one parse per file) that

data/lib/rigor/rooted_glob.rb

@@ -12,6 +12,9 @@ module Rigor
   # would not do that: it reads an absolute pattern, or an absolute alternative, outside `base`. A root without
   # metacharacters is joined unchanged, so the results are the joined glob's strings in its order, `root` kept as
   # given (relative, symlinked or with a trailing `/`).
+  #
+  # `literal(name)` is the same escape for a single name (a file's basename, a configured path) that is joined into
+  # a pattern as a literal: `literal("a[1].rb")` matches `a[1].rb` and not `a1.rb`.
   module RootedGlob
     METACHARACTERS = /[\[\]{}*?\\]/
 
@@ -21,7 +24,13 @@ module Rigor
     # @param pattern — a `Dir.glob` pattern relative to `root`
     # @return the matches spelled under `root`, in `Dir.glob` order; empty when `root` is not a directory
     def glob(root, pattern)
-      Dir.glob(File.join(root.to_s.gsub(METACHARACTERS, "\\\\\\0"), pattern.to_s))
+      Dir.glob(File.join(literal(root), pattern.to_s))
+    end
+
+    # @param name — a file or directory name, taken literally
+    # @return the pattern that matches exactly `name` under `Dir.glob`, with its metacharacters escaped
+    def literal(name)
+      name.to_s.gsub(METACHARACTERS, "\\\\\\0")
     end
   end
 end

data/lib/rigor/scope.rb

@@ -1563,7 +1563,8 @@ module Rigor
     #
     # This is EVIDENCE FOR a singleton ancestor, never against one: the walk sees only what a constant
     # argument to a receiverless `extend` (or, since #915, a receiverless `include` / `prepend` inside a
-    # `class << self` body) written inside a declaration body spells, so a runtime `Widget.extend(m)` and an
+    # `class << self` body) written inside a declaration body spells, or, since #2094, `Widget.extend(M)` and
+    # `Widget.singleton_class.include(M)` with a constant receiver, so a runtime `Widget.extend(m)` and an
     # `extend` in a file outside the analysed set are both absent from it, as is an `extend` declared only
     # in RBS — that one reaches the same consumer through `Environment#singleton_extended_modules` instead.
     # Its one consumer ({Inference::Narrowing.narrow_class}) therefore reads it
@@ -1941,8 +1942,9 @@ module Rigor
     # declaration-level fact of the whole file, which is also the granularity
     # `ScopeIndexer#append_constant_signature` moves the declaration signature at.
     #
-    # `constant_sources` is seeded only when dependency recording is on, so on every ordinary run the table
-    # is empty and this is one Hash miss; the caller additionally gates on the recorder being active.
+    # `constant_sources` is seeded when dependency recording is on and in the editor publish's discovery seed
+    # (ADR-124), where the recorder is inactive; elsewhere the table is empty and this is one Hash miss. The caller
+    # gates on the recorder being active.
     def record_constant_dependency(name)
       sites = @discovery.constant_sources[name]
       return if sites.nil?
@@ -1973,11 +1975,18 @@ module Rigor
     # a wrapping `private def` / `private attr_reader` call, else the surrounding `private` / `protected` / `public`
     # modifier state, plus any post-hoc `private :name, ...` named-argument calls. Consumed by the
     # `def.method-visibility-mismatch` rule so explicit-non-self calls to a private method surface a diagnostic.
-    def discovered_method_visibility(class_name, method_name)
+    # `singleton: true` reads the class's singleton slot for the name (`[:singleton, name]`).
+    #
+    # Issue #2134 — every answer is an ADR-46 read of the slot, so it records `visibility:<class>#<method_name>`
+    # whichever way it answers ({Analysis::DependencyRecorder.read_visibility}). A `private :foo` can be written from
+    # a reopening or a `class_eval` block in a file the reader has no other edge to, and adding or removing it must
+    # re-check the reader.
+    def discovered_method_visibility(class_name, method_name, singleton: false)
+      Analysis::DependencyRecorder.read_visibility(class_name, method_name) if Analysis::DependencyRecorder.active?
       table = @discovery.discovered_method_visibilities[class_name.to_s]
       return nil unless table
 
-      table[method_name.to_sym]
+      table[singleton ? [:singleton, method_name.to_sym] : method_name.to_sym]
     end
 
     # Closes the "`params[:f] ||= []; params[:f] << x`" precision gap (ROADMAP § Type-language / engine —