rigortype 0.1.5 → 0.1.7

data/lib/rigor/plugin/manifest.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "../inference/hkt_registry"
+
 module Rigor
   module Plugin
     # Value object describing one plugin's identity and metadata.
@@ -11,7 +13,7 @@ module Rigor
     # The fields are pinned by ADR-2 § "Registration, Configuration,
     # and Caching"; the v0.1.0 plugin contract surface treats this
     # struct as the public manifest shape.
-    class Manifest
+    class Manifest # rubocop:disable Metrics/ClassLength
       # Same regex {Rigor::Cache::Store::VALID_PRODUCER_ID} uses,
       # so plugin ids round-trip through cache producer ids and
       # `plugin.<id>.<rule>` diagnostic identifiers without escape.
@@ -39,13 +41,14 @@ module Rigor
 
       attr_reader :id, :version, :description, :protocols, :config_schema, :produces, :consumes,
                   :owns_receivers, :type_node_resolvers, :block_as_methods, :heredoc_templates,
-                  :trait_registries, :external_files
+                  :trait_registries, :external_files, :hkt_registrations, :hkt_definitions
 
       def initialize( # rubocop:disable Metrics/ParameterLists
         id:, version:,
         description: nil, protocols: [], config_schema: {},
         produces: [], consumes: [], owns_receivers: [], type_node_resolvers: [],
-        block_as_methods: [], heredoc_templates: [], trait_registries: [], external_files: []
+        block_as_methods: [], heredoc_templates: [], trait_registries: [], external_files: [],
+        hkt_registrations: [], hkt_definitions: []
       )
         validate_id!(id)
         validate_version!(version)
@@ -58,9 +61,12 @@ module Rigor
         validate_heredoc_templates!(heredoc_templates)
         validate_trait_registries!(trait_registries)
         validate_external_files!(external_files)
+        validate_hkt_registrations!(hkt_registrations)
+        validate_hkt_definitions!(hkt_definitions)
 
         assign_fields(id, version, description, protocols, config_schema, produces, consumes, owns_receivers,
-                      type_node_resolvers, block_as_methods, heredoc_templates, trait_registries, external_files)
+                      type_node_resolvers, block_as_methods, heredoc_templates, trait_registries, external_files,
+                      hkt_registrations, hkt_definitions)
         freeze
       end
 
@@ -68,7 +74,8 @@ module Rigor
 
       # rubocop:disable Metrics/ParameterLists, Metrics/AbcSize
       def assign_fields(id, version, description, protocols, config_schema, produces, consumes, owns_receivers,
-                        type_node_resolvers, block_as_methods, heredoc_templates, trait_registries, external_files)
+                        type_node_resolvers, block_as_methods, heredoc_templates, trait_registries, external_files,
+                        hkt_registrations, hkt_definitions)
         @id = id.dup.freeze
         @version = version.dup.freeze
         @description = description.nil? ? nil : description.to_s.dup.freeze
@@ -82,6 +89,8 @@ module Rigor
         @heredoc_templates = heredoc_templates.dup.freeze
         @trait_registries = trait_registries.dup.freeze
         @external_files = external_files.dup.freeze
+        @hkt_registrations = hkt_registrations.dup.freeze
+        @hkt_definitions = hkt_definitions.dup.freeze
       end
       # rubocop:enable Metrics/ParameterLists, Metrics/AbcSize
 
@@ -110,7 +119,7 @@ module Rigor
         errors
       end
 
-      def to_h
+      def to_h # rubocop:disable Metrics/AbcSize
         {
           "id" => id,
           "version" => version,
@@ -124,7 +133,9 @@ module Rigor
           "block_as_methods" => block_as_methods.map(&:to_h),
           "heredoc_templates" => heredoc_templates.map(&:to_h),
           "trait_registries" => trait_registries.map(&:to_h),
-          "external_files" => external_files.map(&:to_h)
+          "external_files" => external_files.map(&:to_h),
+          "hkt_registrations" => hkt_registrations.map(&:to_h),
+          "hkt_definitions" => hkt_definitions.map { |d| { "uri" => d.uri, "params" => d.params } }
         }
       end
 
@@ -279,6 +290,42 @@ module Rigor
               "Rigor::Plugin::Macro::ExternalFile instances, got #{entries.inspect}"
       end
 
+      # ADR-20 slice 6 — `hkt_registrations:` declares the
+      # Lightweight HKT URI registrations this plugin ships
+      # (analogous to `%a{rigor:v1:hkt_register: ...}` directives
+      # but published via the manifest contract instead of a
+      # shipped `.rbs` file). Each entry MUST be an
+      # `Rigor::Inference::HktRegistry::Registration`. The
+      # registry aggregator on `Plugin::Registry` flattens
+      # entries from every loaded plugin and merges them into
+      # `env.hkt_registry` on top of `Builtins::HktBuiltins.registry`;
+      # user `.rbs` overlays merge on top of plugin entries
+      # last-write-wins.
+      def validate_hkt_registrations!(entries)
+        return if entries.is_a?(Array) && entries.all?(Inference::HktRegistry::Registration)
+
+        raise ArgumentError,
+              "plugin manifest hkt_registrations must be an Array of " \
+              "Rigor::Inference::HktRegistry::Registration instances, got #{entries.inspect}"
+      end
+
+      # ADR-20 slice 6 — `hkt_definitions:` declares the
+      # plugin's HKT type-function bodies (analogous to
+      # `%a{rigor:v1:hkt_define: ...}` directives). Each entry
+      # MUST be an `Rigor::Inference::HktRegistry::Definition`
+      # — typically built via
+      # `Rigor::Inference::HktRegistry.definition_with_body_tree(...)`
+      # so plugin authors can build the body programmatically
+      # via {Rigor::Inference::HktBody}'s node-constructor API
+      # without parsing a string.
+      def validate_hkt_definitions!(entries)
+        return if entries.is_a?(Array) && entries.all?(Inference::HktRegistry::Definition)
+
+        raise ArgumentError,
+              "plugin manifest hkt_definitions must be an Array of " \
+              "Rigor::Inference::HktRegistry::Definition instances, got #{entries.inspect}"
+      end
+
       def coerce_consumes(consumes)
         unless consumes.is_a?(Array)
           raise ArgumentError, "plugin manifest consumes must be an Array, got #{consumes.inspect}"

data/lib/rigor/plugin/registry.rb

@@ -85,6 +85,25 @@ module Rigor
         plugins.flat_map { |plugin| plugin.manifest.type_node_resolvers }
       end
 
+      # ADR-20 slice 6 — aggregate every loaded plugin's
+      # manifest-declared HKT registrations + definitions
+      # into a single `Inference::HktRegistry` overlay that
+      # `Environment#hkt_registry` merges on top of the
+      # bundled `Builtins::HktBuiltins.registry`. Last
+      # plugin to register a URI wins (registration order
+      # determined by the user's `plugins:` list); user
+      # `.rbs` overlays merge on top of this overlay last.
+      # Returns `Inference::HktRegistry::EMPTY` when no
+      # plugin contributes HKT entries so callers can skip
+      # the merge.
+      def hkt_overlay_registry
+        registrations = plugins.flat_map { |plugin| plugin.manifest.hkt_registrations }
+        definitions = plugins.flat_map { |plugin| plugin.manifest.hkt_definitions }
+        return Inference::HktRegistry::EMPTY if registrations.empty? && definitions.empty?
+
+        Inference::HktRegistry.new(registrations: registrations, definitions: definitions)
+      end
+
       EMPTY = new.freeze
     end
   end

data/lib/rigor/rbs_extended/hkt_directives.rb

@@ -0,0 +1,326 @@
+# frozen_string_literal: true
+
+require_relative "../inference/hkt_registry"
+require_relative "../inference/hkt_body_parser"
+
+module Rigor
+  module RbsExtended
+    # ADR-20 § "Decision D6" parser for the two new HKT
+    # directives that live in `.rbs` files at module / class
+    # scope:
+    #
+    # - `%a{rigor:v1:hkt_register: uri=<uri> arity=<int>
+    #   variance=<v1>,<v2>,... bound=<class_name_or_untyped>}` —
+    #   registers a defunctionalised type-constructor URI
+    #   together with its arity, per-position variance, and
+    #   erasure bound.
+    # - `%a{rigor:v1:hkt_define: uri=<uri> params=<P1>,<P2>,...
+    #   body=<body_text>}` — binds the URI to a type-function
+    #   body that {HktBodyParser} parses into an
+    #   {HktBody::Union} tree.
+    #
+    # ## Payload format
+    #
+    # **Space-separated `key=value` pairs.** The format is
+    # constrained by RBS's `%a{...}` annotation grammar, which
+    # does NOT accept arbitrary nested punctuation (a JSON
+    # payload with quotes / nested braces will fail RBS
+    # parsing). Each value is a bare token: no quoting, no
+    # escaping. Values that contain spaces or `=` signs MUST
+    # be encoded via the `body=` key, which is special-cased
+    # to gobble everything from `body=` to the end of the
+    # payload — see `parse_define`.
+    #
+    # Example annotations (write inside a class / module
+    # declaration so the annotation attaches to the decl
+    # RBS parses):
+    #
+    #   %a{rigor:v1:hkt_register: uri=json::value arity=1
+    #     variance=out bound=untyped}
+    #   %a{rigor:v1:hkt_define: uri=json::value params=K
+    #     body=nil | true | false | Integer | Float | String |
+    #          Array[App[json::value, K]] |
+    #          Hash[K, App[json::value, K]]}
+    #   module JsonOverlay
+    #   end
+    #
+    # ## Bound vocabulary
+    #
+    # - `untyped` resolves to `Rigor::Type::Combinator.untyped`
+    #   (i.e. `Dynamic[Top]`, the ADR-20 WD2 default).
+    # - A bare class name (`String`, `Integer`, …) resolves
+    #   through `name_scope.nominal_for_name(...)` when
+    #   supplied, falling back to a raw `Rigor::Type::Nominal`
+    #   otherwise.
+    # - Anything else falls back to `untyped` and emits an
+    #   `:info` diagnostic via the supplied reporter (fail-soft
+    #   so an unrecognised bound never crashes the loader).
+    #
+    # Richer bound forms (parameterised generics, unions,
+    # refinements) wait for a follow-up slice's expression
+    # parser.
+    module HktDirectives
+      module_function
+
+      REGISTER_DIRECTIVE = "rigor:v1:hkt_register:"
+      DEFINE_DIRECTIVE   = "rigor:v1:hkt_define:"
+
+      DEFAULT_VARIANCE = :inv
+      DEFAULT_BOUND_LITERAL = "untyped"
+
+      # Parses one `%a{rigor:v1:hkt_register: ...}` payload
+      # string and returns a `Registration`, or `nil` when the
+      # string is not an hkt_register directive (so callers can
+      # walk a list of annotations without each having to
+      # pre-filter).
+      def parse_register(string, name_scope: nil, reporter: nil, source_location: nil)
+        payload = extract_payload(string, REGISTER_DIRECTIVE)
+        return nil if payload.nil?
+
+        kvs = parse_kv_payload(payload, body_key: nil)
+
+        uri = symbolize_uri(kvs["uri"], reporter: reporter, source_location: source_location)
+        return nil if uri.nil?
+
+        arity = coerce_arity(kvs["arity"], reporter: reporter, source_location: source_location)
+        return nil if arity.nil?
+
+        variance = coerce_variance(kvs["variance"], arity, reporter: reporter, source_location: source_location)
+        return nil if variance.nil?
+
+        bound = resolve_bound(
+          kvs["bound"] || DEFAULT_BOUND_LITERAL,
+          name_scope: name_scope,
+          reporter: reporter,
+          source_location: source_location
+        )
+
+        Inference::HktRegistry::Registration.new(
+          uri: uri,
+          arity: arity,
+          variance: variance,
+          bound: bound
+        )
+      rescue ArgumentError => e
+        record_hkt_error(reporter, "hkt_register: #{e.message}", source_location)
+        nil
+      end
+
+      # Parses one `%a{rigor:v1:hkt_define: ...}` payload
+      # string and returns a `Definition`, or `nil` when the
+      # string is not an hkt_define directive.
+      def parse_define(string, reporter: nil, source_location: nil)
+        payload = extract_payload(string, DEFINE_DIRECTIVE)
+        return nil if payload.nil?
+
+        kvs = parse_kv_payload(payload, body_key: "body")
+
+        uri = symbolize_uri(kvs["uri"], reporter: reporter, source_location: source_location)
+        return nil if uri.nil?
+
+        params = coerce_params(kvs["params"], reporter: reporter, source_location: source_location)
+        return nil if params.nil?
+
+        body = kvs["body"]
+        unless body.is_a?(String)
+          record_hkt_error(reporter, "hkt_define: missing body=", source_location)
+          return nil
+        end
+
+        body_tree = parse_body_tree(body, params, reporter: reporter, source_location: source_location)
+
+        Inference::HktRegistry::Definition.new(
+          uri: uri,
+          params: params,
+          body: body,
+          body_tree: body_tree,
+          source_path: source_path_of(source_location),
+          source_line: source_line_of(source_location)
+        )
+      rescue ArgumentError => e
+        record_hkt_error(reporter, "hkt_define: #{e.message}", source_location)
+        nil
+      end
+
+      def extract_payload(string, directive)
+        return nil if string.nil?
+
+        idx = string.index(directive)
+        return nil if idx.nil?
+
+        payload = string[(idx + directive.size)..].to_s.strip
+        # Strip trailing `}` of the wrapping `%a{...}` form if
+        # the caller passed the raw annotation string. The
+        # parser also accepts a pre-extracted payload.
+        payload = payload.sub(/\}\z/, "") if payload.end_with?("}") && !balanced_braces?(payload)
+        payload.empty? ? nil : payload
+      end
+
+      def balanced_braces?(string)
+        depth = 0
+        string.each_char do |ch|
+          case ch
+          when "{" then depth += 1
+          when "}"
+            depth -= 1
+            return false if depth.negative?
+          end
+        end
+        depth.zero?
+      end
+
+      # Parses a space-separated `key=value [key=value ...]`
+      # payload into a Hash. When `body_key` is supplied AND
+      # that key appears, everything from `<body_key>=` to
+      # the end of the payload becomes the value (body
+      # contents typically include spaces, `|`, `[]` etc.
+      # that the simple tokenizer cannot otherwise carry).
+      KV_KEY_PATTERN = /(?<![\w.])([a-z_]\w*)=/
+      private_constant :KV_KEY_PATTERN
+
+      def parse_kv_payload(payload, body_key:)
+        result = {}
+        # Find every `<key>=` boundary; each value runs to
+        # the next boundary or end of string.
+        markers = []
+        payload.scan(KV_KEY_PATTERN) { markers << [::Regexp.last_match[1], ::Regexp.last_match.end(0)] }
+        markers.each_with_index do |(key, value_start), i|
+          if body_key && key == body_key
+            result[key] = payload[value_start..].to_s.strip
+            break
+          end
+
+          value_end = markers[i + 1] ? markers[i + 1][1] - markers[i + 1][0].size - 1 : payload.size
+          result[key] = payload[value_start...value_end].to_s.strip
+        end
+        result
+      end
+
+      # ADR-20 slice 2b — parse the body String into an
+      # `HktBody::*` tree via {Inference::HktBodyParser.parse}.
+      # On parse failure: emit a fail-soft `:info` reporter
+      # entry and return `nil` so the resulting Definition
+      # keeps its `body` String slot but `body_tree` stays
+      # absent (the reducer falls back to `app.bound` at call
+      # time per ADR-20 D5).
+      def parse_body_tree(body, params, reporter:, source_location:)
+        return nil if body.nil? || body.empty?
+
+        Inference::HktBodyParser.parse(body, params: params)
+      rescue Inference::HktBodyParser::ParseError => e
+        record_hkt_error(reporter, "hkt_define body parse error: #{e.message}", source_location)
+        nil
+      rescue ArgumentError => e
+        record_hkt_error(reporter, "hkt_define body construction error: #{e.message}", source_location)
+        nil
+      end
+
+      def symbolize_uri(raw, reporter:, source_location:)
+        if raw.nil? || raw.empty?
+          record_hkt_error(reporter, "uri= is required", source_location)
+          return nil
+        end
+        unless raw.include?(Type::App::URI_SEPARATOR)
+          record_hkt_error(
+            reporter,
+            "uri must be namespaced as `a::b` per ADR-20 WD1, got #{raw.inspect}",
+            source_location
+          )
+          return nil
+        end
+
+        raw.to_sym
+      end
+
+      def coerce_arity(raw, reporter:, source_location:)
+        if raw && /\A\d+\z/.match?(raw) && raw.to_i.positive?
+          raw.to_i
+        else
+          record_hkt_error(reporter, "arity must be a positive Integer, got #{raw.inspect}", source_location)
+          nil
+        end
+      end
+
+      def coerce_variance(raw, arity, reporter:, source_location:)
+        # Omitted variance defaults to `[:inv] * arity` per ADR-20 WD4.
+        variance =
+          if raw.nil? || raw.empty?
+            Array.new(arity, DEFAULT_VARIANCE)
+          else
+            raw.split(",").map { |v| v.strip.to_sym }
+          end
+
+        unless variance.size == arity
+          record_hkt_error(reporter, "variance length #{variance.size} does not match arity #{arity}", source_location)
+          return nil
+        end
+
+        unless variance.all? { |v| %i[out in inv].include?(v) }
+          record_hkt_error(
+            reporter,
+            "variance entries must be `out` / `in` / `inv`, got #{variance.inspect}",
+            source_location
+          )
+          return nil
+        end
+
+        variance
+      end
+
+      def coerce_params(raw, reporter:, source_location:)
+        if raw.nil? || raw.empty?
+          record_hkt_error(reporter, "params= is required (comma-separated UCName list)", source_location)
+          return nil
+        end
+
+        raw.split(",").map { |p| p.strip.to_sym }
+      end
+
+      def resolve_bound(raw, name_scope:, reporter:, source_location:)
+        return Type::Combinator.untyped if raw.nil? || raw.strip.empty?
+        return Type::Combinator.untyped if raw.strip == DEFAULT_BOUND_LITERAL
+
+        class_name = raw.strip
+        if /\A(?:::)?(?:[A-Z]\w*)(?:::[A-Z]\w*)*\z/.match?(class_name)
+          normalized = class_name.sub(/\A::/, "")
+          return Type::Nominal.new(normalized) if name_scope.nil?
+
+          if name_scope.respond_to?(:nominal_for_name)
+            resolved = name_scope.nominal_for_name(normalized)
+            return resolved if resolved
+          end
+          return Type::Nominal.new(normalized)
+        end
+
+        record_hkt_error(
+          reporter,
+          "bound `#{raw}` not recognised (accepts `untyped` or a bare class name); falling back to `untyped`",
+          source_location
+        )
+        Type::Combinator.untyped
+      end
+
+      def source_path_of(source_location)
+        return nil if source_location.nil?
+
+        source_location.respond_to?(:name) ? source_location.name : nil
+      end
+
+      def source_line_of(source_location)
+        return nil if source_location.nil?
+
+        source_location.respond_to?(:start_line) ? source_location.start_line : nil
+      end
+
+      def record_hkt_error(reporter, message, source_location)
+        return if reporter.nil?
+
+        if reporter.respond_to?(:record)
+          reporter.record(directive: "hkt", message: message, source_location: source_location)
+        elsif reporter.respond_to?(:<<)
+          reporter << { directive: "hkt", message: message, source_location: source_location }
+        end
+      end
+    end
+  end
+end

data/lib/rigor/rbs_extended.rb

@@ -4,6 +4,7 @@ require_relative "type"
 require_relative "builtins/imported_refinements"
 require_relative "flow_contribution"
 require_relative "rbs_extended/reporter"
+require_relative "rbs_extended/hkt_directives"
 
 module Rigor
   # Slice 7 phase 15 — first-preview reader for the
@@ -385,13 +386,15 @@ module Rigor
 
       name_scope = environment&.name_scope
       reporter = environment&.rbs_extended_reporter
+      hkt_registry = environment&.hkt_registry
 
       annotations.each do |annotation|
         type = parse_return_type_override(
           annotation.string,
           name_scope: name_scope,
           reporter: reporter,
-          source_location: annotation.location
+          source_location: annotation.location,
+          hkt_registry: hkt_registry
         )
         return type if type
       end
@@ -417,10 +420,40 @@ module Rigor
     /x
     private_constant :RETURN_DIRECTIVE_PATTERN
 
-    def parse_return_type_override(string, name_scope: nil, reporter: nil, source_location: nil)
+    # ADR-20 slice 2d — recognises `App[<uri>, <ClassName>, ...]`
+    # syntax in a `rigor:v1:return:` payload before falling
+    # through to the refinement-name parser. The match captures
+    # the namespaced URI (`json::value`) plus a comma-separated
+    # list of bare class names (`String`, `Symbol`, `Integer`).
+    # Slice 2d keeps the arg vocabulary intentionally narrow;
+    # parameterised forms (`Array[T]`, `Hash[K, V]`), unions,
+    # and refinements inside `App[...]` wait for a follow-up
+    # slice's expression parser.
+    APP_PAYLOAD_PATTERN = /
+      \A
+      App\[
+      \s*
+      (?<uri>[a-z_][a-z0-9_]*(?:::[a-z_][a-z0-9_]*)+)
+      \s*,\s*
+      (?<args>[^\[\]]+?)
+      \s*\]
+      \z
+    /x
+    private_constant :APP_PAYLOAD_PATTERN
+
+    def parse_return_type_override(string, name_scope: nil, reporter: nil, source_location: nil, hkt_registry: nil)
       match = RETURN_DIRECTIVE_PATTERN.match(string)
       return nil if match.nil?
 
+      app_type = parse_app_payload(
+        match[:payload],
+        name_scope: name_scope,
+        reporter: reporter,
+        source_location: source_location,
+        hkt_registry: hkt_registry
+      )
+      return app_type if app_type
+
       type = Builtins::ImportedRefinements.parse(
         match[:payload],
         name_scope: name_scope,
@@ -431,6 +464,53 @@ module Rigor
       type
     end
 
+    # ADR-20 slice 2d. Parses `App[<uri>, <ClassName>, ...]`
+    # syntax into a `Rigor::Type::App`. When `hkt_registry` is
+    # supplied and the URI is registered with a body_tree, the
+    # `App` is reduced eagerly via {Inference::HktRegistry#reduce}
+    # so call sites observe the unfolded form (e.g.
+    # `Union[nil, true, false, ..., Array[App[json::value,
+    # String]], Hash[String, App[json::value, String]]]`)
+    # rather than the opaque carrier. When the registry is
+    # absent or the URI is unregistered, the carrier with its
+    # registry-supplied bound (or `untyped` as a last-resort
+    # fallback) is returned as-is.
+    def parse_app_payload(payload, name_scope: nil, reporter: nil, source_location: nil, hkt_registry: nil)
+      match = APP_PAYLOAD_PATTERN.match(payload)
+      return nil if match.nil?
+
+      uri = match[:uri].to_sym
+      arg_classes = match[:args].split(",").map(&:strip)
+      args = arg_classes.map { |name| resolve_app_arg(name, name_scope: name_scope) }
+
+      if args.any?(&:nil?)
+        record_unresolved(reporter, "App payload `#{payload}`: unresolved arg class name", source_location)
+        return nil
+      end
+
+      registration = hkt_registry&.registration(uri)
+      bound = registration&.bound || Type::Combinator.untyped
+      app = Type::App.new(uri, args, bound: bound)
+
+      return app if hkt_registry.nil? || !hkt_registry.defined?(uri)
+
+      reduced = hkt_registry.reduce(app)
+      reduced || app
+    end
+
+    def resolve_app_arg(class_name, name_scope: nil)
+      return nil unless /\A(?:::)?(?:[A-Z]\w*)(?:::[A-Z]\w*)*\z/.match?(class_name)
+
+      normalized = class_name.sub(/\A::/, "")
+      return Type::Nominal.new(normalized) if name_scope.nil?
+
+      if name_scope.respond_to?(:nominal_for_name)
+        resolved = name_scope.nominal_for_name(normalized)
+        return resolved if resolved
+      end
+      Type::Nominal.new(normalized)
+    end
+
     # Returned for `rigor:v1:param: <name> <refinement>`. The
     # parameter name is a Ruby identifier (Symbol); the type
     # is any `Rigor::Type` the refinement parser resolves

data/lib/rigor/sig_gen/generator.rb

@@ -52,6 +52,15 @@ module Rigor
         @paths = paths
         @observations = normalize_observations(observations)
         @include_private = include_private
+        # Per-file scratch state. `analyse_file` resets each
+        # one to a fresh container for every file walked so
+        # candidates from one file don't leak into another;
+        # initialising empty here gives downstream consumers
+        # (`build_candidate`, `method_def_prefix`) a never-nil
+        # invariant without per-call-site defensive guards.
+        @namespace_kinds = {}
+        @module_function_methods = Set.new
+        @class_shells = Set.new
       end
 
       # Lifts legacy plain-`Array[Type]` observation entries
@@ -270,8 +279,8 @@ module Rigor
       # `Const = Data.define(...)` declarations.
       def build_candidate(**)
         MethodCandidate.new(
-          namespace_kinds: @namespace_kinds || {},
-          class_shells: (@class_shells || Set.new).to_a,
+          namespace_kinds: @namespace_kinds,
+          class_shells: @class_shells.to_a,
           **
         )
       end
@@ -282,7 +291,7 @@ module Rigor
       # dispatch at runtime), or "def " (plain instance).
       def method_def_prefix(class_name, method_name, kind)
         return "def self." if kind == :singleton
-        return "def self?." if @module_function_methods&.include?([class_name, method_name])
+        return "def self?." if @module_function_methods.include?([class_name, method_name])
 
         "def "
       end