rigortype 0.3.2 → 0.3.4

data/plugins/rigor-activerecord/sig/active_record/relation.rbs

@@ -26,6 +26,26 @@
 # `rbs collection`), that definition conflicts with this one and
 # the conflict degrades through Rigor's plugin-RBS failure memo
 # (ADR-25 WD4) — the richer upstream definition simply wins.
+#
+# ## Effect annotations (ADR-103 WD10, issue #387)
+#
+# Every method carries an effect annotation, and the split down
+# the middle of this file is the whole point of the Rails effect
+# layer: a **builder** is `%a{pure}` because it issues nothing —
+# `where` composes an Arel tree and returns a relation — while a
+# **materializer** is `%a{rigor:v1:effect io.db.read}` because it
+# is the call that finally runs the query. A presenter that builds
+# and returns a scope has pure code; the caller that materialises
+# it gets the read. That is the truthful reading of what the code
+# does, not of how Rails developers narrate it.
+#
+# This is the plugin's tier-1 channel: these are *accepted
+# signatures*, so a call site importing one of these bounds is
+# exhaustive rather than tainted (ADR-103 WD6). The methods this
+# file does not declare — `map`, `filter_map` and the rest of the
+# `Enumerable` surface, which materialise by delegating to `each`
+# — are covered by the plugin's `effect_attributions:` instead,
+# because declaring them here would change how they TYPE.
 
 module ActiveRecord
   class Relation[Elem]
@@ -34,149 +54,274 @@ module ActiveRecord
     # `Enumerable` only *requires* `each` (the includer supplies
     # it); it is declared here so `relation.each { |m| ... }`
     # resolves and the block parameter carries the element type.
+    %a{rigor:v1:effect io.db.read}
     def each: () { (Elem) -> void } -> self
             | () -> Enumerator[Elem, self]
 
     # --- query builders (return another relation) ---
+    %a{pure}
     def where: (*untyped) ?{ () -> untyped } -> self
+    %a{pure}
     def rewhere: (*untyped) -> self
+    %a{pure}
     def not: (*untyped) -> self
+    %a{pure}
     def or: (untyped) -> self
+    %a{pure}
     def and: (untyped) -> self
+    %a{pure}
     def order: (*untyped) -> self
+    %a{pure}
     def reorder: (*untyped) -> self
+    %a{pure}
     def in_order_of: (*untyped) -> self
+    %a{pure}
     def limit: (untyped) -> self
+    %a{pure}
     def offset: (untyped) -> self
+    %a{pure}
     def distinct: (?untyped) -> self
+    %a{pure}
     def group: (*untyped) -> self
+    %a{pure}
     def regroup: (*untyped) -> self
+    %a{pure}
     def having: (*untyped) -> self
+    %a{pure}
     def includes: (*untyped) -> self
+    %a{pure}
     def preload: (*untyped) -> self
+    %a{pure}
     def eager_load: (*untyped) -> self
+    %a{pure}
     def joins: (*untyped) -> self
+    %a{pure}
     def left_joins: (*untyped) -> self
+    %a{pure}
     def left_outer_joins: (*untyped) -> self
+    %a{pure}
     def references: (*untyped) -> self
+    %a{pure}
     def select: (*untyped) -> self
+    %a{pure}
     def reselect: (*untyped) -> self
+    %a{pure}
     def unscope: (*untyped) -> self
+    %a{pure}
     def merge: (untyped) -> self
+    %a{pure}
     def except: (*untyped) -> self
+    %a{pure}
     def only: (*untyped) -> self
+    %a{pure}
     def extending: (*untyped) -> self
+    %a{pure}
     def from: (untyped, ?untyped) -> self
+    %a{pure}
     def lock: (?untyped) -> self
+    %a{pure}
     def readonly: (?untyped) -> self
+    %a{pure}
     def strict_loading: (?untyped) -> self
+    %a{pure}
     def create_with: (untyped) -> self
+    %a{pure}
     def none: () -> self
+    %a{pure}
     def all: () -> self
+    %a{pure}
     def unscoped: () -> self
+    %a{pure}
     def default_scoped: () -> self
+    %a{pure}
     def annotate: (*untyped) -> self
+    %a{pure}
     def optimizer_hints: (*untyped) -> self
+    %a{pure}
     def excluding: (*untyped) -> self
+    %a{pure}
     def without: (*untyped) -> self
+    %a{pure}
     def with: (*untyped) -> self
     def scoping: () { () -> untyped } -> untyped
 
     # --- finders (return an element) ---
+    %a{rigor:v1:effect io.db.read}
     def find: (*untyped) -> Elem
+    %a{rigor:v1:effect io.db.read}
     def find_by: (*untyped) -> Elem?
+    %a{rigor:v1:effect io.db.read}
     def find_by!: (*untyped) -> Elem
+    %a{rigor:v1:effect io.db.read}
     def find_sole_by: (*untyped) -> Elem
+    %a{rigor:v1:effect io.db.read}
     def sole: () -> Elem
+    %a{rigor:v1:effect io.db.read}
     def first: () -> Elem?
             | (Integer limit) -> Array[Elem]
+    %a{rigor:v1:effect io.db.read}
     def first!: () -> Elem
+    %a{rigor:v1:effect io.db.read}
     def last: () -> Elem?
            | (Integer limit) -> Array[Elem]
+    %a{rigor:v1:effect io.db.read}
     def last!: () -> Elem
+    %a{rigor:v1:effect io.db.read}
     def take: () -> Elem?
            | (Integer limit) -> Array[Elem]
+    %a{rigor:v1:effect io.db.read}
     def take!: () -> Elem
+    %a{rigor:v1:effect io.db.read}
     def second: () -> Elem?
+    %a{rigor:v1:effect io.db.read}
     def third: () -> Elem?
+    %a{rigor:v1:effect io.db.read}
     def fourth: () -> Elem?
+    %a{rigor:v1:effect io.db.read}
     def fifth: () -> Elem?
+    %a{rigor:v1:effect io.db.read}
     def forty_two: () -> Elem?
+    %a{rigor:v1:effect io.db.read}
     def second_to_last: () -> Elem?
+    %a{rigor:v1:effect io.db.read}
     def third_to_last: () -> Elem?
 
     # --- batched enumeration ---
+    %a{rigor:v1:effect io.db.read}
     def find_each: (**untyped) ?{ (Elem) -> void } -> untyped
+    %a{rigor:v1:effect io.db.read}
     def find_in_batches: (**untyped) ?{ (Array[Elem]) -> void } -> untyped
+    %a{rigor:v1:effect io.db.read}
     def in_batches: (**untyped) ?{ (ActiveRecord::Relation[Elem]) -> void } -> untyped
 
     # --- scalars / aggregates ---
+    %a{rigor:v1:effect io.db.read}
     def count: (*untyped) ?{ (Elem) -> untyped } -> untyped
+    %a{rigor:v1:effect io.db.read}
     def sum: (*untyped) ?{ (Elem) -> untyped } -> untyped
+    %a{rigor:v1:effect io.db.read}
     def average: (untyped) -> untyped
+    %a{rigor:v1:effect io.db.read}
     def minimum: (untyped) -> untyped
+    %a{rigor:v1:effect io.db.read}
     def maximum: (untyped) -> untyped
+    %a{rigor:v1:effect io.db.read}
     def calculate: (*untyped) -> untyped
+    %a{rigor:v1:effect io.db.read}
     def pluck: (*untyped) -> Array[untyped]
+    %a{rigor:v1:effect io.db.read}
     def pick: (*untyped) -> untyped
+    %a{rigor:v1:effect io.db.read}
     def ids: () -> Array[untyped]
+    %a{rigor:v1:effect io.db.read}
     def size: () -> Integer
+    %a{rigor:v1:effect io.db.read}
     def length: () -> Integer
+    %a{rigor:v1:effect io.db.read}
     def empty?: () -> bool
+    %a{rigor:v1:effect io.db.read}
     def any?: (*untyped) ?{ (Elem) -> boolish } -> bool
+    %a{rigor:v1:effect io.db.read}
     def none?: (*untyped) ?{ (Elem) -> boolish } -> bool
+    %a{rigor:v1:effect io.db.read}
     def one?: (*untyped) ?{ (Elem) -> boolish } -> bool
+    %a{rigor:v1:effect io.db.read}
     def many?: () ?{ (Elem) -> boolish } -> bool
+    %a{rigor:v1:effect io.db.read}
     def exists?: (*untyped) -> bool
+    %a{rigor:v1:effect io.db.read}
     def include?: (untyped) -> bool
+    %a{rigor:v1:effect io.db.read}
     def member?: (untyped) -> bool
 
     # --- conversion / state ---
+    %a{rigor:v1:effect io.db.read}
     def to_a: () -> Array[Elem]
+    %a{rigor:v1:effect io.db.read}
     def to_ary: () -> Array[Elem]
+    %a{rigor:v1:effect io.db.read}
     def entries: () -> Array[Elem]
+    %a{rigor:v1:effect io.db.read}
     def load: (?untyped) -> self
+    %a{rigor:v1:effect io.db.read}
     def reload: () -> self
+    %a{pure}
     def reset: () -> self
+    %a{pure}
     def loaded?: () -> bool
+    %a{pure}
     def to_sql: () -> String
+    %a{rigor:v1:effect io.db.read}
     def explain: (*untyped) -> String
+    %a{rigor:v1:effect io.db.read}
     def cache_key: (?untyped) -> String
+    %a{rigor:v1:effect io.db.read}
     def cache_version: (?untyped) -> untyped
+    %a{rigor:v1:effect io.db.read}
     def to_json: (*untyped) -> String
+    %a{rigor:v1:effect io.db.read}
     def as_json: (?untyped) -> untyped
+    %a{rigor:v1:effect io.db.read}
     def blank?: () -> bool
+    %a{rigor:v1:effect io.db.read}
     def present?: () -> bool
+    %a{pure}
     def klass: () -> untyped
+    %a{pure}
     def model: () -> untyped
+    %a{pure}
     def table: () -> untyped
+    %a{pure}
     def arel: () -> untyped
 
     # --- whole-relation persistence ---
+    %a{rigor:v1:effect io.db.write}
     def update_all: (untyped) -> Integer
+    %a{rigor:v1:effect io.db.write}
     def delete_all: () -> Integer
+    %a{rigor:v1:effect io.db.write}
     def destroy_all: () -> Array[Elem]
+    %a{rigor:v1:effect io.db.write}
     def update: (*untyped) -> untyped
+    %a{rigor:v1:effect io.db.write}
     def update!: (*untyped) -> untyped
+    %a{rigor:v1:effect io.db.write}
     def delete_by: (*untyped) -> Integer
+    %a{rigor:v1:effect io.db.write}
     def destroy_by: (*untyped) -> Array[Elem]
+    %a{rigor:v1:effect io.db.write}
     def touch_all: (*untyped) -> Integer
+    %a{rigor:v1:effect io.db.write}
     def insert_all: (untyped, **untyped) -> untyped
+    %a{rigor:v1:effect io.db.write}
     def insert_all!: (untyped, **untyped) -> untyped
+    %a{rigor:v1:effect io.db.write}
     def upsert_all: (untyped, **untyped) -> untyped
 
     # --- instantiating builders (return an element) ---
+    %a{pure}
     def new: (*untyped) ?{ (Elem) -> void } -> Elem
+    %a{pure}
     def build: (*untyped) ?{ (Elem) -> void } -> Elem
+    %a{rigor:v1:effect io.db.write}
     def create: (*untyped) ?{ (Elem) -> void } -> Elem
+    %a{rigor:v1:effect io.db.write}
     def create!: (*untyped) ?{ (Elem) -> void } -> Elem
+    %a{rigor:v1:effect io.db.write}
     def find_or_create_by: (untyped) ?{ (Elem) -> void } -> Elem
+    %a{rigor:v1:effect io.db.write}
     def find_or_create_by!: (untyped) ?{ (Elem) -> void } -> Elem
+    %a{rigor:v1:effect io.db.read}
     def find_or_initialize_by: (untyped) ?{ (Elem) -> void } -> Elem
+    %a{rigor:v1:effect io.db.write}
     def create_or_find_by: (untyped) ?{ (Elem) -> void } -> Elem
+    %a{rigor:v1:effect io.db.write}
     def create_or_find_by!: (untyped) ?{ (Elem) -> void } -> Elem
+    %a{rigor:v1:effect io.db.write}
     def first_or_create: (?untyped) ?{ (Elem) -> void } -> Elem
+    %a{rigor:v1:effect io.db.write}
     def first_or_create!: (?untyped) ?{ (Elem) -> void } -> Elem
+    %a{rigor:v1:effect io.db.read}
     def first_or_initialize: (?untyped) ?{ (Elem) -> void } -> Elem
   end
 end

data/plugins/rigor-activestorage/lib/rigor/plugin/activestorage/effects.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require "rigor/plugin"
+
+module Rigor
+  module Plugin
+    class Activestorage < Rigor::Plugin::Base
+      # rigor-activestorage's effect contract (ADR-103 WD10; design note § 11.2; issue #387).
+      #
+      # ActiveStorage is the design note's argument for framework labels in miniature: the *transport* is
+      # whatever `config/storage.yml` names — the local disk, S3, GCS — and is therefore statically
+      # unknowable, while the *operation* is fixed. So every row carries bare `io` for the transport and
+      # `rails.activestorage.read` / `.write` for the meaning, which is the half a policy can grip.
+      #
+      # Almost every write is also an `io.db.write`: an attachment is a row in `active_storage_attachments`
+      # and a blob is a row in `active_storage_blobs`, so `user.avatar.attach(io)` really does touch the
+      # database whether or not the bytes go to S3. A "no database writes on this path" envelope is right
+      # to object, and would be wrong not to.
+      module Effects
+        ATTACHED_ONE = "ActiveStorage::Attached::One"
+        ATTACHED_MANY = "ActiveStorage::Attached::Many"
+        BLOB = "ActiveStorage::Blob"
+        ATTACHMENT = "ActiveStorage::Attachment"
+
+        READ = ["io", "rails.activestorage.read"].freeze
+        WRITE = ["io", "rails.activestorage.write", "io.db.write"].freeze
+        # `download` / `open` pull bytes out of the service and touch no row.
+        PURE_READ = ["io", "rails.activestorage.read"].freeze
+
+        ATTACH_TARGETS = [ATTACHED_ONE, ATTACHED_MANY].freeze
+
+        module_function
+
+        def attributions
+          attach_rows + blob_rows
+        end
+
+        def attach_rows
+          ATTACH_TARGETS.flat_map do |receiver|
+            [
+              row(receiver, :attach, WRITE,
+                  "uploads the bytes to the configured service AND inserts the attachment + blob rows"),
+              row(receiver, :purge, WRITE, "deletes the stored file and the attachment + blob rows"),
+              row(receiver, :purge_later, WRITE,
+                  "enqueues the purge; the attachment row is detached now, so the database write is here"),
+              row(receiver, :detach, ["io.db.write"], "removes the attachment row and touches no service"),
+              row(receiver, :download, PURE_READ, "pulls the bytes back out of the service"),
+              row(receiver, :open, PURE_READ, "streams the bytes into a tempfile")
+            ]
+          end
+        end
+
+        def blob_rows
+          [
+            row(BLOB, :download, PURE_READ, "reads the object out of the storage service"),
+            row(BLOB, :open, PURE_READ, "streams the object into a tempfile"),
+            row(BLOB, :upload, WRITE, "writes the object to the service and records its checksum"),
+            row(BLOB, :purge, WRITE, "deletes the object and its row"),
+            row(BLOB, :purge_later, WRITE, "enqueues the object's deletion; the row goes now"),
+            row(BLOB, :create_and_upload!, WRITE, "inserts the blob row and uploads in one call",
+                singleton: true),
+            row(BLOB, :url, READ, "signs a URL against the service, which for some services is a request"),
+            row(ATTACHMENT, :purge, WRITE, "deletes the stored file and the attachment row"),
+            row(ATTACHMENT, :download, PURE_READ, "reads the attached object out of the service")
+          ]
+        end
+
+        def row(receiver, selector, labels, why, singleton: false)
+          EffectAttribution.new(receiver: receiver, method: selector, labels: labels,
+                                singleton: singleton, discharge: true,
+                                why: "#{why}; the transport is bare `io` because `config/storage.yml` " \
+                                     "decides it per environment and no static reading can")
+        end
+      end
+    end
+  end
+end

data/plugins/rigor-activestorage/lib/rigor/plugin/activestorage.rb

@@ -5,6 +5,7 @@ require "rigor/plugin"
 require_relative "activestorage/attachment_discoverer"
 require_relative "activestorage/attachment_index"
 require_relative "activestorage/analyzer"
+require_relative "activestorage/effects"
 
 module Rigor
   module Plugin
@@ -41,7 +42,11 @@ module Rigor
         config_schema: {
           "model_search_paths" => { kind: :array, default: ["app/models"] }
         },
-        consumes: [{ plugin_id: "activerecord", name: :model_index, optional: true }]
+        consumes: [{ plugin_id: "activerecord", name: :model_index, optional: true }],
+        # ADR-103 WD10 (#387) — see {Effects} for what each row is and why.
+        effect_root: "rails",
+        effect_labels: %w[rails.activestorage.read rails.activestorage.write],
+        effect_attributions: Effects.attributions
       )
 
       # Cached: attachment index. Walks every `.rb` file under `model_search_paths` for `has_*_attached`

data/plugins/rigor-activesupport-core-ext/lib/rigor/plugin/activesupport_core_ext/effects.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+require "rigor/plugin"
+
+module Rigor
+  module Plugin
+    class ActivesupportCoreExt < Rigor::Plugin::Base
+      # rigor-activesupport-core-ext's effect contract (ADR-103 WD10; design note § 11.2; issue #387).
+      #
+      # **Scope note.** This is the *impure* half of ActiveSupport only: the clock, the notification bus and
+      # `CurrentAttributes`. The `%a{pure}` sweep over `blank?` / `present?` / `deep_dup` and the rest of
+      # the core_ext predicate surface — the single cheapest purity win in a Rails app, per WD10 — is issue
+      # #388 and lands in this plugin's shipped RBS, not here (`try` was audited and skipped: it dispatches
+      # to whatever method the caller names, so its purity is a fact about the call site, not about `try`).
+      # One row below (`in_time_zone_row`) is #388's own addition: `DateTime#in_time_zone` reads `Time.zone`
+      # through a default argument, a gap the RBS sweep found but can only fix here.
+      #
+      # ## The clock
+      #
+      # `Time.current` and friends are `nondet.time`, plus `global.read` for the zone: `Time.zone` is
+      # process state that `Time.use_zone` and the per-request `around_action` both change. The distinction
+      # matters for the purity policy of ADR-103 WD9 — a method that calls `Time.current` may never have its
+      # result remembered, and that is the whole reason the label exists.
+      #
+      # ## `CurrentAttributes`
+      #
+      # `Current.user` is fiber-local mutable state: `global.read` on the way in, `global.write` on the way
+      # out, with `rails.current.read` / `.write` as the meaning. Rigor cannot name the attributes per app
+      # — they come from an `attribute :user` macro in the project's own `Current` class — so the rows are
+      # keyed on the framework base class and reach every project subclass through inheritance. `reset` and
+      # `set` are named explicitly because they are the ones a reviewer looks for.
+      module Effects
+        TIME = "Time"
+        DATE = "Date"
+        DATETIME = "DateTime"
+        ZONE = "Time.zone"
+        CURRENT = "ActiveSupport::CurrentAttributes"
+        NOTIFICATIONS = "ActiveSupport::Notifications"
+
+        CLOCK = ["nondet.time", "global.read"].freeze
+        CLOCK_NO_ZONE = ["nondet.time"].freeze
+        ZONE_READ = ["global.read"].freeze
+        CURRENT_READ = ["global.read", "rails.current.read"].freeze
+        CURRENT_WRITE = ["global.write", "rails.current.write"].freeze
+        TELEMETRY = %w[io telemetry].freeze
+
+        # Zone-aware clock readers: they consult `Time.zone`, which is mutable process state.
+        ZONED_NOW = %w[current].freeze
+        # Zone-blind ones. `Time.now` / `Date.today` are already catalogue rows for core Ruby; these are the
+        # ActiveSupport additions.
+        ZONE_BLIND = %w[].freeze
+
+        module_function
+
+        def attributions
+          clock_rows + zone_rows + current_rows + notification_rows + [in_time_zone_row]
+        end
+
+        def clock_rows
+          [
+            row(TIME, :current, CLOCK, singleton: true,
+                                       why: "reads the clock AND `Time.zone`, which `Time.use_zone` and a per-request " \
+                                            "`around_action` both rewrite"),
+            row(DATE, :current, CLOCK, singleton: true, why: "the same, to day precision"),
+            row(DATE, :yesterday, CLOCK, singleton: true, why: "`Date.current - 1`"),
+            row(DATE, :tomorrow, CLOCK, singleton: true, why: "`Date.current + 1`"),
+            row(DATETIME, :current, CLOCK, singleton: true, why: "the DateTime spelling of `Time.current`"),
+            row("ActiveSupport::TimeZone", :now, CLOCK_NO_ZONE, singleton: true,
+                                                                why: "the zone is the receiver here, so only the clock read is left"),
+            row(ZONE, :now, CLOCK_NO_ZONE, why: "`Time.zone.now` — the zone is named, the clock is read"),
+            row(ZONE, :today, CLOCK_NO_ZONE, why: "`Time.zone.today`")
+          ] + duration_rows
+        end
+
+        # `2.days.ago` / `3.hours.from_now`. The receiver is an `ActiveSupport::Duration`; the call reads
+        # the clock, which is what makes `created_at > 7.days.ago` a `nondet.time` expression and not a
+        # constant.
+        def duration_rows
+          %w[ago until since from_now after before].map do |selector|
+            row("ActiveSupport::Duration", selector, CLOCK,
+                why: "`n.days.ago` and its family read the clock (and the zone) at the call — this is what " \
+                     "stops a duration comparison folding to a constant")
+          end
+        end
+
+        def zone_rows
+          [
+            row(TIME, :zone, ZONE_READ, singleton: true,
+                                        why: "reads the process/fiber's current time zone, which is mutable"),
+            row(TIME, :zone=, ["global.write"], singleton: true,
+                                                why: "rewrites the process/fiber's time zone for everything downstream"),
+            row(TIME, :use_zone, ["global.write"], singleton: true,
+                                                   why: "swaps the zone around a block; the block's own origins join by containment")
+          ]
+        end
+
+        # `DateTime#in_time_zone` — a gap the #388 `%a{pure}` sweep over `sig/active_support/core_ext.rbs`
+        # surfaced: `in_time_zone(zone = ::Time.zone)` reads `Time.zone` through its own default argument
+        # whenever the caller doesn't pass one explicitly, so it cannot be annotated `%a{pure}` there. It
+        # belongs here rather than in the RBS because the label is `global.read` alone (not the
+        # `nondet.time` + `global.read` pair `CLOCK` carries) — `in_time_zone` converts an already-fixed
+        # instant into a zone, it does not read the clock itself.
+        def in_time_zone_row
+          row("DateTime", :in_time_zone, ZONE_READ,
+              why: "the default argument reads `Time.zone` when the caller doesn't name one explicitly")
+        end
+
+        def current_rows
+          [
+            row(CURRENT, :set, CURRENT_WRITE, singleton: true,
+                                              why: "writes fiber-local request state that every later read in the request sees"),
+            row(CURRENT, :reset, CURRENT_WRITE, singleton: true, why: "clears the same fiber-local state"),
+            row(CURRENT, :attributes, CURRENT_READ, singleton: true, why: "reads the whole bag"),
+            row(CURRENT, :attributes=, CURRENT_WRITE, singleton: true, why: "replaces the whole bag"),
+            row(CURRENT, :instance, CURRENT_READ, singleton: true,
+                                                  why: "materialises the per-fiber instance the accessors read through")
+          ]
+        end
+
+        def notification_rows
+          [
+            EffectAttribution.new(
+              receiver: NOTIFICATIONS, method: :instrument, labels: TELEMETRY, singleton: true,
+              discharge: true, taint: "opaque-callable",
+              why: "publishes to the notification bus — `io` because a subscriber may do anything and " \
+                   "`telemetry` because that is the meaning. The taint is the honest half: the SUBSCRIBERS " \
+                   "are registered at runtime and the analyzer cannot see them, so the summary reads " \
+                   "'this much, and possibly more'"
+            ),
+            row(NOTIFICATIONS, :publish, TELEMETRY, singleton: true, why: "the bare publish"),
+            row(NOTIFICATIONS, :subscribe, ["mutate.static"], singleton: true,
+                                                              why: "registers a subscriber on process-global state")
+          ]
+        end
+
+        def row(receiver, selector, labels, why:, singleton: false)
+          EffectAttribution.new(receiver: receiver, method: selector, labels: labels,
+                                singleton: singleton, discharge: true, why: why)
+        end
+      end
+    end
+  end
+end

data/plugins/rigor-activesupport-core-ext/lib/rigor/plugin/activesupport_core_ext.rb

@@ -2,6 +2,8 @@
 
 require "rigor/plugin"
 
+require_relative "activesupport_core_ext/effects"
+
 module Rigor
   module Plugin
     # ADR-25 — a pure RBS-bundle plugin. It ships NO analyzer code: no `diagnostics_for_file`, no
@@ -24,7 +26,13 @@ module Rigor
         # aliases that return Time, not Date).
         version: "0.2.0",
         description: "RBS bundle for the most-frequently-flagged ActiveSupport core_ext extensions.",
-        signature_paths: ["sig"]
+        signature_paths: ["sig"],
+        # ADR-103 WD10 (#387) — the IMPURE half of ActiveSupport: the clock, the notification bus and
+        # `CurrentAttributes`. The `%a{pure}` sweep over the predicate surface is issue #388 and lands in
+        # `sig/`, not here. See {Effects}.
+        effect_root: "rails",
+        effect_labels: %w[rails.current.read rails.current.write],
+        effect_attributions: Effects.attributions
       )
     end