rigortype 0.4.5 → 0.4.7

data/sig/rigor/inference/optimistic_origin.rbs

@@ -5,6 +5,17 @@ module Rigor
       # (sig.skipped.untyped-return). The answer is the recorded `true` / `false` / `nil`, or the `UNKNOWN_MISS`
       # sentinel; declaring it is what lets sig-gen type `Scope#optimistic_local_miss` / `#optimistic_ivar_miss`.
       def self?.bound_miss: (untyped mark) -> Object?
+
+      class BoundMark < ::Data
+        # sig-gen gap: #1150 — a `Data.define` member; sig-gen proposes `untyped`. The cause a mark records.
+        def cause: () -> Symbol
+        # sig-gen gap: #1150 — a `Data.define` member; the recorded miss answer.
+        def miss: () -> bool?
+        # sig-gen gap: #1150 — the `Data.define` constructor; sig-gen types its members `untyped`.
+        def self.new: (cause: Symbol, miss: bool?) -> instance | (Symbol cause, bool? miss) -> instance
+        # sig-gen gap: #1150 — as above.
+        def self.[]: (cause: Symbol, miss: bool?) -> instance | (Symbol cause, bool? miss) -> instance
+      end
     end
   end
 end

data/sig/rigor/inference.rbs

@@ -3,7 +3,8 @@ module Rigor
     type closure_classification = :non_escaping | :escaping | :unknown
 
     class ExpressionTyper
-      def self.harvest_return_memo: () -> Hash[untyped, Array[untyped]]
+      def self.harvest_return_memo: (?Hash[untyped, Hash[untyped, untyped]]? bucket) -> Hash[untyped, Array[untyped]]
+      def self.current_return_memo: () -> Hash[untyped, Hash[untyped, untyped]]?
       def initialize: (scope: Scope, ?tracer: FallbackTracer?) -> void
       def type_of: (untyped node) -> Type::t
       def return_type_for: (untyped def_node, Type::t receiver, Array[Type::t] arg_types) -> Type::t?
@@ -172,8 +173,16 @@ module Rigor
       def self?.collect_class_decls: (untyped node, Array[String] qualified_prefix, Hash[String, Type::t] accumulator) -> void
       def self?.constant_writes_for_file: (untyped root) -> Hash[String, untyped]
       def self?.constant_literal_value: (untyped rvalue) -> Array[untyped]?
+      # authored: the `Set[String]` values are source paths by contract; a Set's element type stays `untyped` in sig-gen (#2177, #2317), so the generator
+      # would never propose it.
       def self?.finalize_constant_writes: (Hash[String, Hash[String, untyped]] writes) -> [Hash[String, Type::Constant], Hash[String, Set[String]]]
       def self?.propagate: (untyped node, Hash[untyped, Scope] table, Scope parent_scope) -> void
+
+      class LayeredDefNestings
+        def initialize: (Hash[untyped, Array[String]] file, Scope::DiscoveryIndex::def_nestings seed) -> void
+        def []: (untyped def_node) -> Array[String]?
+        def empty?: () -> bool
+      end
     end
 
     class CoverageScanner

data/sig/rigor/plugin/additional_initializer.rbs

@@ -4,15 +4,10 @@ module Rigor
     # the read-before-write nil soundness gate does not widen their ivars. See
     # lib/rigor/plugin/additional_initializer.rb for the full contract.
     class AdditionalInitializer
-      # sig-gen gap: #1154 — `attr_reader` rows over ivars assigned from `initialize` parameters are
-      # skipped (untyped return); the constructor validates `receiver_constraint` is a non-empty
-      # String and normalizes both lists with `map(&:to_sym)`, so the stored types are hand-written.
       attr_reader receiver_constraint: String
 
-      # sig-gen gap: #1154 — as above.
       attr_reader methods: Array[Symbol]
 
-      # sig-gen gap: #1154 — as above.
       attr_reader block_methods: Array[Symbol]
 
       # The validators accept Symbol or non-empty String elements; `initialize` normalizes to

data/sig/rigor/plugin/base.rbs

@@ -84,5 +84,6 @@ class Rigor::Plugin::Base
   def effect_ancestry: () -> Array[Rigor::Plugin::EffectAncestry]
   def io_boundary: () -> Rigor::Plugin::IoBoundary
   def cache_for: (untyped producer_id, ?params: untyped, ?descriptor: untyped) -> Proc
+  # authored: returns Rigor::Cache::Descriptor::PluginEntry, which has no RBS declaration yet (#2404); stays `untyped` until it is declared
   def plugin_entry: () -> untyped
 end

data/sig/rigor/plugin/effect_ancestry.rbs

@@ -5,12 +5,14 @@ module Rigor
     # immediate superclass. Bundled plugins only — `Effects::PluginFacts` enforces it. Frozen value
     # object.
     class EffectAncestry
-      # sig-gen gap: #1154 — validated in `initialize` from the parameter of the same name
-      # (`to_s`-normalized, frozen), so sig-gen proposes the raw parameter shape.
+      # sig-gen gap: #2312 — `child:` is `untyped` (input `untyped`, looks deliberate; a declared type is authoring
+      # intent tracked by #2325, and only then does this row generate; coercion-facing: `to_s`, then a class-name
+      # check), and `initialize` stores the private `validate_class_name!` helper's result (#2312).
       attr_reader child: String
-      # sig-gen gap: #1154 — same shape as `child`.
+      # sig-gen gap: #2312 — same shape as `child`.
       attr_reader parent: String
-      # sig-gen gap: #1154 — same shape; `why:` is required and validated non-empty.
+      # sig-gen gap: #2312 — same shape; `why:` is `untyped` and the private `validate_why!` helper (#2312) requires
+      # it non-empty.
       attr_reader why: String
 
       def initialize: (child: untyped, parent: untyped, why: untyped) -> void

data/sig/rigor/plugin/effect_attribution.rbs

@@ -15,28 +15,43 @@ module Rigor
       # The taint causes a plugin row may name — a closed subset of `Effects::TaintCause::ALL`.
       TAINT_CAUSES: Array[String]
 
-      # sig-gen gap: #1154 — normalized/validated in `initialize` from the parameter of the same
-      # name (`to_s`-coerced, frozen), so sig-gen proposes the raw parameter shape.
+      # sig-gen gap: #2312 — `receiver:` is `untyped` (input `untyped`, looks deliberate; a declared type is authoring
+      # intent tracked by #2325, and only then does this row generate; coercion-facing: `to_s`), and `initialize`
+      # stores the private `validate_receiver!` helper's result (#2312).
       attr_reader receiver: String
-      # sig-gen gap: #1154 — `to_sym`-normalized from the `method:` parameter.
+      # sig-gen gap: #2325 — `method:` is `untyped` (input `untyped`, looks deliberate; a declared type is authoring
+      # intent tracked by #2325, and only then does this row generate; coercion-facing: `String | Symbol`), stored as
+      # `method.to_sym`.
       attr_reader method: Symbol
       attr_reader singleton: bool
-      # sig-gen gap: #1154 — `Array()`-normalized, deduplicated and frozen from `labels:`.
+      # sig-gen gap: #2312 — `labels:` is `untyped` (input `untyped`, looks deliberate; a declared type is authoring
+      # intent tracked by #2325, and only then does this row generate; coercion-facing: `Array()` of anything
+      # answering `to_s`), stored from the private `normalize_labels` helper (#2312).
       attr_reader labels: Array[String]
-      # sig-gen gap: #1154 — `to_s`-normalized from the `narrow:` parameter.
+      # sig-gen gap: #2325 — `narrow:` is `untyped` (input `untyped`, looks deliberate; a declared type is authoring
+      # intent tracked by #2325, and only then does this row generate; coercion-facing: `to_s`, nil kept).
       attr_reader narrow: String?
       attr_reader discharge: bool
-      # sig-gen gap: #1154 — `to_s`-normalized from the `within:` parameter.
+      # sig-gen gap: #2312 — `within:` is `untyped` (input `untyped`, looks deliberate; a declared type is authoring
+      # intent tracked by #2325, and only then does this row generate; coercion-facing: `to_s`), stored from the
+      # private `validate_within!` helper (#2312).
       attr_reader within: String?
       attr_reader on_result: bool
-      # sig-gen gap: #1154 — `to_s`-normalized from the `taint:` parameter.
+      # sig-gen gap: #2312 — `taint:` is `untyped` (input `untyped`, looks deliberate; a declared type is authoring
+      # intent tracked by #2325, and only then does this row generate; coercion-facing: `to_s`), stored from the
+      # private `validate_taint!` helper (#2312).
       attr_reader taint: String?
-      # sig-gen gap: #1154 — `to_s`-normalized from the `callee:` parameter.
+      # sig-gen gap: #2325 — `callee:` is `untyped` (input `untyped`, looks deliberate; a declared type is authoring
+      # intent tracked by #2325, and only then does this row generate; coercion-facing: `to_s`, nil kept).
       attr_reader callee: String?
-      # sig-gen gap: #1154 — normalized from the `callee_fallbacks:` parameter.
+      # sig-gen gap: #2312 — `callee_fallbacks:` is `untyped` (input `untyped`, looks deliberate; a declared type is
+      # authoring intent tracked by #2325, and only then does this row generate; coercion-facing: a Hash of coercible
+      # names), stored from the private `validate_callee_fallbacks!` helper (#2312).
       attr_reader callee_fallbacks: Hash[String, Array[String]]?
       attr_reader responds: bool
-      # sig-gen gap: #1154 — `to_s`-normalized from the `why:` parameter.
+      # sig-gen gap: #2312 — `why:` is `untyped` (input `untyped`, looks deliberate; a declared type is authoring
+      # intent tracked by #2325, and only then does this row generate; coercion-facing: `to_s`), stored from the
+      # private `validate_why!` helper (#2312).
       attr_reader why: String
 
       # The coercion-facing constructor: every parameter is `to_s`/`to_sym`/`Array()`-normalized,

data/sig/rigor/plugin/effect_edge.rbs

@@ -7,15 +7,22 @@ module Rigor
       # The closed set of framework-edge strategies the engine implements.
       TARGETS: Array[Symbol]
 
-      # sig-gen gap: #1154 — validated/normalized in `initialize` from the parameter of the same
-      # name, so sig-gen proposes the raw parameter shape.
+      # sig-gen gap: #2312 — `receiver:` is `untyped` (input `untyped`, looks deliberate; a declared type is authoring
+      # intent tracked by #2325, and only then does this row generate; coercion-facing: `to_s`), and `initialize`
+      # stores the result of the private `validate_receiver!` helper (#2312).
       attr_reader receiver: String
-      # sig-gen gap: #1154 — `to_sym`-normalized from the `method:` parameter.
+      # sig-gen gap: #2325 — `method:` is `untyped` (input `untyped`, looks deliberate; a declared type is authoring
+      # intent tracked by #2325, and only then does this row generate; coercion-facing: `String | Symbol | nil`),
+      # stored as `method&.to_sym`.
       attr_reader method: Symbol?
       attr_reader singleton: bool
-      # sig-gen gap: #1154 — validated against `TARGETS` in `initialize`.
+      # sig-gen gap: #2312 — `target:` is `untyped` (input `untyped`, looks deliberate; a declared type is authoring
+      # intent tracked by #2325, and only then does this row generate; coercion-facing: a Symbol or String checked
+      # against `TARGETS`), stored from the private `validate_target!` helper (#2312).
       attr_reader target: (:activerecord_callbacks | :perform_now | :mailer_body)
-      # sig-gen gap: #1154 — `to_s`-normalized from the `why:` parameter.
+      # sig-gen gap: #2312 — `why:` is `untyped` (input `untyped`, looks deliberate; a declared type is authoring
+      # intent tracked by #2325, and only then does this row generate; coercion-facing: `to_s`), stored from the
+      # private `validate_why!` helper (#2312).
       attr_reader why: String
 
       def initialize: (receiver: untyped, target: untyped, why: untyped, ?method: untyped,

data/sig/rigor/plugin/effect_entry_points.rbs

@@ -4,11 +4,16 @@ module Rigor
     # framework entry points (ADR-103 WD6). Frozen value object; {#globs} are deduplicated and
     # sorted in `initialize`.
     class EffectEntryPoints
-      # sig-gen gap: #1154 — `to_s`-normalized in `initialize` from the `name:` parameter.
+      # sig-gen gap: #2325 — `initialize` declares `name:` `untyped` (input `untyped`, looks deliberate; a declared
+      # type is authoring intent tracked by #2325, and only then does this row generate; coercion-facing: it takes
+      # anything that answers `to_s`), so no input type reaches the reader.
       attr_reader name: String
-      # sig-gen gap: #1154 — deduplicated/sorted/frozen in `initialize` from `globs:`.
+      # sig-gen gap: #2325 — `globs:` is `untyped` (input `untyped`, looks deliberate; a declared type is authoring
+      # intent tracked by #2325, and only then does this row generate; coercion-facing: `Array(globs)`, each `to_s`),
+      # deduplicated and sorted in `initialize`.
       attr_reader globs: Array[String]
-      # sig-gen gap: #1154 — `to_s`-normalized in `initialize` from `why:`.
+      # sig-gen gap: #2325 — `why:` is `untyped` (input `untyped`, looks deliberate; a declared type is authoring
+      # intent tracked by #2325, and only then does this row generate; coercion-facing: `to_s`).
       attr_reader why: String
 
       def initialize: (name: untyped, globs: untyped, ?why: untyped) -> void

data/sig/rigor/plugin/io_boundary.rbs

@@ -4,17 +4,18 @@ class Rigor::Plugin::IoBoundary
   def file?: (untyped) -> bool
   def directory?: (untyped) -> bool
   def list_directory: (untyped) -> Array[String]
-  def list_directory_kinds: (untyped) -> Hash[String, untyped]
+  def list_directory_kinds: (untyped) -> Hash[String, Symbol]
   # Records a `:names` glob row (membership only); a caller needing a match's content `read_file`s it. A `..`
   # segment, a brace or a backslash in `pattern` raises `AccessDeniedError`.
   def glob: (untyped root, untyped pattern) -> Array[String]
-  # sig-gen gap: #1154 — the proposal leaves both string fields untyped. `nearest_root` comes from `@policy`, an
-  # ivar assigned from an `initialize` parameter (the #1154 shape); `first_path` comes from `@first_refused_path`,
-  # written from `record_refusal(path)`'s parameter outside `initialize`, a case #1154 as titled does not yet cover.
-  # The record's fields are the running count and the first refused path, nil when nothing was refused.
+  # sig-gen gap: #2312 — the proposal leaves both string fields untyped. `nearest_root` comes from `@policy`, a bare
+  # assignment of the `policy:` parameter, declared `untyped` above (a `TrustPolicy`; typing it is authoring work,
+  # tracked by #2325); `first_path` comes from `@first_refused_path`, written from the private `record_refusal(path)`,
+  # whose parameter is undeclared.
   def refusal_summary: () -> { count: Integer, first_path: String?, nearest_root: String? }?
   def open_url: (untyped url) -> String
   # Returns a frozen `Rigor::Cache::Descriptor` (no RBS yet -> untyped).
+  # authored: returns Rigor::Cache::Descriptor, which has no RBS declaration yet (#2404); stays `untyped` until it is declared
   def cache_descriptor: () -> untyped
   def replay: (untyped descriptor) -> nil
 end

data/sig/rigor/plugin/manifest.rbs

@@ -3,7 +3,7 @@ class Rigor::Plugin::Manifest::Consumption
 end
 
 class Rigor::Plugin::Manifest
-  def initialize: (id: untyped, version: untyped, ?description: untyped, ?config_schema: untyped, ?target_gems: untyped, ?produces: untyped, ?consumes: untyped, ?owns_receivers: untyped, ?open_receivers: untyped, ?rbs_complete_ancestors: untyped, ?type_node_resolvers: untyped, ?block_as_methods: untyped, ?heredoc_templates: untyped, ?nested_class_templates: untyped, ?trait_registries: untyped, ?hkt_registrations: untyped, ?hkt_definitions: untyped, ?signature_paths: untyped, ?protocol_contracts: Array[Rigor::Plugin::ProtocolContract], ?source_rbs_synthesizer: untyped, ?additional_initializers: Array[Rigor::Plugin::AdditionalInitializer], ?effect_root: String?, ?effect_labels: Array[String], ?effect_attributions: Array[Rigor::Plugin::EffectAttribution], ?effect_edges: Array[Rigor::Plugin::EffectEdge], ?effect_entry_points: Array[Rigor::Plugin::EffectEntryPoints], ?effect_ancestry: Array[Rigor::Plugin::EffectAncestry], ?template_globs: untyped) -> void
+  def initialize: (id: untyped, version: untyped, ?description: untyped, ?config_schema: untyped, ?target_gems: untyped, ?produces: untyped, ?consumes: untyped, ?owns_receivers: untyped, ?open_receivers: untyped, ?rbs_complete_ancestors: untyped, ?type_node_resolvers: untyped, ?block_as_methods: untyped, ?heredoc_templates: untyped, ?nested_class_templates: untyped, ?trait_registries: untyped, ?hkt_registrations: untyped, ?hkt_definitions: untyped, ?signature_paths: untyped, ?protocol_contracts: Array[Rigor::Plugin::ProtocolContract], ?source_rbs_synthesizer: untyped, ?additional_initializers: Array[Rigor::Plugin::AdditionalInitializer], ?effect_root: String?, ?effect_labels: Array[String], ?effect_attributions: Array[Rigor::Plugin::EffectAttribution], ?effect_edges: Array[Rigor::Plugin::EffectEdge], ?effect_entry_points: Array[Rigor::Plugin::EffectEntryPoints], ?effect_ancestry: Array[Rigor::Plugin::EffectAncestry], ?template_globs: Array[String], ?per_invocation_classes: Array[String], ?per_invocation_non_action_macros: Array[Symbol | String]) -> void
 
   # Public attribute readers (the full `attr_reader` surface). Plugins
   # read `manifest.id` / `manifest.protocol_contracts` etc.; declaring
@@ -18,9 +18,9 @@ class Rigor::Plugin::Manifest
   def config_schema: () -> untyped
   def config_defaults: () -> Hash[String, untyped]
   def target_gems: () -> Array[String]
-  # sig-gen gap: #1154 — an `attr_reader` over an ivar assigned in `initialize` from a parameter the
-  # manifest validates but does not type, so inference reaches `untyped` where the contract is
-  # `Array[String]` (the same gap every other reader in this block carries).
+  # sig-gen gap: #2418 — written by a private `assign_*` helper whose parameters are undeclared (`initialize` hands
+  # its fields to such helpers); each write is a derived expression (`dup.freeze`, `map`), so the helper's parameter
+  # types alone would not generate it.
   def template_globs: () -> Array[String]
   def produces: () -> Array[Symbol]
   def consumes: () -> Array[Rigor::Plugin::Manifest::Consumption]
@@ -35,33 +35,31 @@ class Rigor::Plugin::Manifest
   def hkt_registrations: () -> untyped
   def hkt_definitions: () -> untyped
   def signature_paths: () -> Array[String]
-  # sig-gen gap: #1154 — `attr_reader` over an ivar assigned in `initialize` from a parameter;
-  # `validate_protocol_contracts!` requires every element `is_a?(ProtocolContract)`.
+  # sig-gen gap: #2418 — same shape as `template_globs`: `validate_protocol_contracts!` requires every element
+  # `is_a?(ProtocolContract)`.
   def protocol_contracts: () -> Array[Rigor::Plugin::ProtocolContract]
   # ADR-32 WD6/WD12 — any object responding to `call`, and its result is a documented multi-shape
   # outcome (`String` / nil / `[:error, msg]` / `[:ok, src, msgs]`), not `String?` — `untyped` is the
   # honest claim until the outcome has a sig'd shape.
   def source_rbs_synthesizer: () -> untyped
-  # sig-gen gap: #1154 — `attr_reader` over an ivar assigned in `initialize` from a parameter;
-  # the validator (`validate_additional_initializers!`) requires every element
-  # `is_a?(AdditionalInitializer)`, so the element type is hand-written.
+  # sig-gen gap: #2418 — same shape as `template_globs`: the validator (`validate_additional_initializers!`) requires
+  # every element `is_a?(AdditionalInitializer)`, so the element type is hand-written.
   def additional_initializers: () -> Array[Rigor::Plugin::AdditionalInitializer]
 
-  # sig-gen gap: #1154 — `attr_reader` over an ivar assigned in `initialize` from a parameter
-  # (`to_s`-normalized); `validate_effect_root!` bounds the spelling.
+  # sig-gen gap: #2418 — same shape as `template_globs`: `validate_effect_root!` bounds the spelling.
   def effect_root: () -> String?
-  # sig-gen gap: #1154 — `attr_reader` over an ivar normalized in `initialize` from a parameter;
-  # `validate_effect_labels!` requires non-empty `String` elements.
+  # sig-gen gap: #2418 — same shape as `template_globs`: `validate_effect_labels!` requires non-empty `String`
+  # elements.
   def effect_labels: () -> Array[String]
-  # sig-gen gap: #1154 — `attr_reader` over an ivar assigned in `initialize` from a parameter;
-  # `validate_effect_attributions!` requires every element `is_a?(EffectAttribution)`.
+  # sig-gen gap: #2418 — same shape as `template_globs`: `validate_effect_attributions!` requires every element
+  # `is_a?(EffectAttribution)`.
   def effect_attributions: () -> Array[Rigor::Plugin::EffectAttribution]
-  # sig-gen gap: #1154 — same shape; `validate_effect_edges!` requires `is_a?(EffectEdge)`.
+  # sig-gen gap: #2418 — same shape as `template_globs`: `validate_effect_edges!` requires `is_a?(EffectEdge)`.
   def effect_edges: () -> Array[Rigor::Plugin::EffectEdge]
-  # sig-gen gap: #1154 — same shape; `validate_effect_entry_points!` requires
+  # sig-gen gap: #2418 — same shape as `template_globs`: `validate_effect_entry_points!` requires
   # `is_a?(EffectEntryPoints)`.
   def effect_entry_points: () -> Array[Rigor::Plugin::EffectEntryPoints]
-  # sig-gen gap: #1154 — same shape; `validate_effect_ancestry!` requires `is_a?(EffectAncestry)`.
+  # sig-gen gap: #2418 — same shape as `template_globs`: `validate_effect_ancestry!` requires `is_a?(EffectAncestry)`.
   def effect_ancestry: () -> Array[Rigor::Plugin::EffectAncestry]
 
   # The identity opening a root when this plugin's labels join the run's vocabulary: the

data/sig/rigor/plugin/protocol_contract.rbs

@@ -23,26 +23,23 @@ module Rigor
         def self.[]: (index: Integer, type_name: String) -> instance | (Integer index, String type_name) -> instance
       end
 
-      # sig-gen gap: #1154 — `attr_reader` rows over ivars assigned in `initialize`; each is
-      # validated/normalized first (`dup.freeze`/`to_sym`/truthiness collapse/coerce), so the
-      # stored types are hand-written.
       attr_reader path_glob: String
 
-      # sig-gen gap: #1154 — as above (`to_sym` normalizes the accepted Symbol|String).
       attr_reader method_name: Symbol
 
       # `singleton ? true : false` collapses any truthy input to bool — sig-gen already infers
-      # `false | true`, so this row is generated-equivalent rather than a #1154 gap.
+      # `false | true`, so this row is generated-equivalent rather than a gap.
       attr_reader singleton: bool
 
-      # sig-gen gap: #1154 — as above (`coerce_param_types` guarantees `Array[ParamType]`).
+      # sig-gen gap: #2312 — `initialize` stores what the private `coerce_param_types` helper returns, whose
+      # parameters are undeclared (it guarantees `Array[ParamType]`).
       attr_reader param_types: Array[ParamType]
 
-      # sig-gen gap: #1154 — as above (nil or a non-empty `dup.freeze`d String).
       attr_reader return_type_name: String?
 
-      # sig-gen gap: #1154 — as above (`VALID_SEVERITIES.include?(to_sym)` bounds the stored value
-      # to the three declared literals).
+      # authored: the declared literal union is intent. `initialize` stores `severity.to_sym` after
+      # `validate_severity!` bounds it to `VALID_SEVERITIES`, so the value is one of the three literals, but sig-gen
+      # generates `Symbol` for it, not the union.
       attr_reader severity: :error | :warning | :info
 
       # `method_name`/`severity` accept String too (both are `to_sym`'d); `param_types` entries are

data/sig/rigor/plugin/registry.rbs

@@ -18,7 +18,7 @@ class Rigor::Plugin::Registry
 
   # Newly declared — the attr_reader was absent from the sig. `compile_aggregates` builds the ivar
   # with `flat_map` over the manifests (not from an `initialize` parameter, so this is unmarked
-  # residue like the `rbs_complete_ancestors` sibling rather than a #1154 row); the element type is
+  # residue like the `rbs_complete_ancestors` sibling rather than a parameter-credit row); the element type is
   # `AdditionalInitializer`, enforced per manifest by `validate_additional_initializers!`.
   attr_reader additional_initializers: Array[Rigor::Plugin::AdditionalInitializer]