rigortype 0.1.14 → 0.1.16

data/lib/rigor/inference/scope_indexer.rb

@@ -107,22 +107,28 @@ module Rigor
         # introduced method names. `rigor check` consults the
         # table to suppress false positives for methods the
         # user has defined but no RBS sig describes.
-        discovered_methods = build_discovered_methods(root)
+        # Merged UNDER any cross-file pre-pass seed (like the def-node
+        # / include tables below) so a method `def`/`attr_reader`-
+        # declared in one file suppresses a false `undefined-method`
+        # for a call in another — `rigor check` seeds the project-wide
+        # table via `Runner#seed_project_scope`.
+        discovered_methods = deep_merge_class_methods(
+          default_scope.discovered_methods, build_discovered_methods(root)
+        )
         seeded_scope = seeded_scope.with_discovered_methods(discovered_methods)
 
         # v0.0.2 #5 + ADR-24 slice 2 — record per-instance-method
         # def nodes, the class -> superclass map, and the
         # class/module -> included-modules map, each merged under
         # the cross-file pre-pass seed (see below).
-        seeded_scope = merge_project_method_indexes(seeded_scope, default_scope, root)
-
         # v0.1.2 — per-class table of method visibilities
         # (`:public` / `:private` / `:protected`). The
-        # `def.method-visibility-mismatch` CheckRule consults
-        # the table to flag explicit-non-self calls to a
-        # private user method.
-        discovered_method_visibilities = build_discovered_method_visibilities(root)
-        seeded_scope = seeded_scope.with_discovered_method_visibilities(discovered_method_visibilities)
+        # `def.method-visibility-mismatch` and ADR-35
+        # `def.override-visibility-reduced` CheckRules consult the
+        # table. Seeded inside `merge_project_method_indexes` so the
+        # per-file visibilities merge OVER the cross-file project seed
+        # rather than overwriting it.
+        seeded_scope = merge_project_method_indexes(seeded_scope, default_scope, root)
 
         table = {}.compare_by_identity
         table.default = seeded_scope
@@ -161,11 +167,18 @@ module Rigor
         includes = default_scope.discovered_includes.merge(
           build_discovered_includes(root)
         ) { |_class, cross_file, per_file| (cross_file + per_file).uniq }
+        # ADR-35 — per-file visibilities merged OVER the cross-file
+        # seed (the current file is authoritative for its own classes;
+        # sibling-file ancestors are preserved from the project seed).
+        method_visibilities = default_scope.discovered_method_visibilities.merge(
+          build_discovered_method_visibilities(root)
+        ) { |_class, cross_file, per_file| cross_file.merge(per_file) }
 
         seeded_scope
           .with_discovered_def_nodes(def_nodes)
           .with_discovered_superclasses(superclasses)
           .with_discovered_includes(includes)
+          .with_discovered_method_visibilities(method_visibilities)
       end
 
       # Slice 7 phase 2. Builds the class-level ivar accumulator
@@ -377,7 +390,7 @@ module Rigor
         # class body has been walked, using `init_writes` as
         # the soundness gate (an ivar written in `initialize`
         # is initialised before any other method body runs).
-        collect_read_before_write_evidence(def_node, class_name, read_before_write, init_writes)
+        collect_read_before_write_evidence(def_node, class_name, read_before_write, init_writes, default_scope)
       end
 
       # Walks the method body in AST (== execution) order
@@ -388,14 +401,21 @@ module Rigor
       # `init_writes` instead — used by the finalisation step
       # to suppress nil contribution for ivars the constructor
       # guarantees are initialised.
-      def collect_read_before_write_evidence(def_node, class_name, read_before_write, init_writes)
+      def collect_read_before_write_evidence(def_node, class_name, read_before_write, init_writes, default_scope = nil)
         return if read_before_write.nil? || init_writes.nil?
 
         seen_writes = Set.new
         read_first = Set.new
         detect_read_before_write(def_node.body, seen_writes, read_first)
 
-        if def_node.name == :initialize
+        # ADR-38 — `initialize` is the built-in initializer gate;
+        # a plugin may declare additional `def`-form initializer
+        # methods (minitest `setup`, Rails `after_initialize`, DI
+        # setters) on a constrained class. Both fold their writes
+        # into `init_writes`, suppressing the read-before-write nil
+        # contribution for sibling readers.
+        if def_node.name == :initialize ||
+           additional_initializer?(class_name, def_node.name, default_scope)
           init_set = (init_writes[class_name] ||= Set.new)
           seen_writes.each { |name| init_set << name }
           return
@@ -407,6 +427,43 @@ module Rigor
         read_first.each { |name| rbw_set << name }
       end
 
+      # ADR-38 — true when a loaded plugin declares `method_name` an
+      # additional initializer for `class_name` (or an ancestor).
+      # Reads the plugin registry off the pre-pass scope's
+      # environment; the receiver-constraint match reuses
+      # `Environment#class_ordering` (the same mechanism ADR-16
+      # Tier A's `MacroBlockSelfType` uses). The whole lookup is
+      # wrapped so any resolution failure degrades to "no match" —
+      # since the gate only ever SUPPRESSES a nil contribution, a
+      # missed match is false-positive-safe (it merely leaves the
+      # existing nil widening in place).
+      def additional_initializer?(class_name, method_name, default_scope)
+        return false if class_name.nil? || default_scope.nil?
+
+        environment = default_scope.environment
+        registry = environment&.plugin_registry
+        return false if registry.nil?
+        return false if registry.respond_to?(:empty?) && registry.empty?
+        return false unless registry.respond_to?(:additional_initializers)
+
+        registry.additional_initializers.any? do |entry|
+          entry.covers_method?(method_name) &&
+            class_matches_constraint?(class_name, entry.receiver_constraint, environment)
+        end
+      rescue StandardError
+        false
+      end
+
+      def class_matches_constraint?(class_name, constraint, environment)
+        return true if class_name == constraint
+        return false if environment.nil?
+
+        ordering = environment.class_ordering(class_name, constraint)
+        %i[equal subclass].include?(ordering)
+      rescue StandardError
+        false
+      end
+
       IVAR_WRITE_NODES = [
         Prism::InstanceVariableWriteNode,
         Prism::InstanceVariableOrWriteNode,
@@ -796,7 +853,19 @@ module Rigor
         accumulator.transform_values(&:freeze).freeze
       end
 
-      # rubocop:disable Metrics/CyclomaticComplexity, Metrics/MethodLength
+      # Merges two `class_name => { method => kind }` tables, unioning
+      # the per-class method maps (so a seeded cross-file table and the
+      # current file's table combine instead of clobbering).
+      def deep_merge_class_methods(base, overlay)
+        return overlay if base.nil? || base.empty?
+        return base if overlay.empty?
+
+        base.merge(overlay) do |_class_name, base_methods, overlay_methods|
+          base_methods.merge(overlay_methods)
+        end
+      end
+
+      # rubocop:disable Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/AbcSize
       def walk_methods(node, qualified_prefix, in_singleton_class, accumulator)
         return unless node.is_a?(Prism::Node)
 
@@ -830,6 +899,10 @@ module Rigor
           return
         when Prism::CallNode
           record_define_method(node, qualified_prefix, in_singleton_class, accumulator) if node.name == :define_method
+          if ATTR_MACROS.include?(node.name)
+            record_attr_methods(node, qualified_prefix, in_singleton_class,
+                                accumulator)
+          end
         end
 
         node.compact_child_nodes.each do |child|
@@ -860,7 +933,7 @@ module Rigor
           end
         end
       end
-      # rubocop:enable Metrics/CyclomaticComplexity, Metrics/MethodLength
+      # rubocop:enable Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/AbcSize
 
       # v0.1.2 — when a `Const = Data.define(*sym) do ... end`
       # / `Const = Struct.new(*sym) do ... end` constant write
@@ -1301,6 +1374,35 @@ module Rigor
         accumulator[class_name][method_name] = in_singleton_class ? :singleton : :instance
       end
 
+      # The `attr_*` accessor macros that introduce methods Rigor must
+      # treat as source-declared. Without this, a class that defines an
+      # accessor with `attr_reader :x` AND carries RBS that omits `x`
+      # (a common gap — the project ships an incomplete `sig/`) fires a
+      # false `call.undefined-method` on `obj.x`, because the
+      # undefined-method rule only suppressed `def` / `define_method` /
+      # `alias_method`-discovered methods. `attr_reader` defines
+      # readers, `attr_writer` writers (`x=`), `attr_accessor` both.
+      ATTR_MACROS = %i[attr_reader attr_writer attr_accessor].freeze
+
+      def record_attr_methods(call_node, qualified_prefix, in_singleton_class, accumulator)
+        return if qualified_prefix.empty?
+        return unless call_node.receiver.nil? # only the implicit-self macro defines on the lexical class
+        return if call_node.arguments.nil?
+
+        kind = in_singleton_class ? :singleton : :instance
+        reader = call_node.name != :attr_writer
+        writer = call_node.name != :attr_reader
+        class_name = qualified_prefix.join("::")
+        call_node.arguments.arguments.each do |arg|
+          base = literal_method_name(arg)
+          next if base.nil?
+
+          accumulator[class_name] ||= {}
+          accumulator[class_name][base] = kind if reader
+          accumulator[class_name][:"#{base}="] = kind if writer
+        end
+      end
+
       def literal_method_name(node)
         return nil unless node.is_a?(Prism::SymbolNode) || node.is_a?(Prism::StringNode)
 
@@ -1365,31 +1467,86 @@ module Rigor
       # (`Mastodon::CLI::Accounts` calling a helper defined in
       # `Mastodon::CLI::Base`).
       #
+      # The returned `def_sources` map mirrors `def_nodes` but stores
+      # a `"path:line"` String per `(class_name, method_name)` instead
+      # of the `Prism::DefNode`. A `Prism::Location` does not expose
+      # its source file through public API, so the source site is
+      # captured here, in the pre-pass loop that still holds `path`.
+      # `CheckRules#undefined_method_diagnostic` consults the seeded
+      # copy to name the defining file when a project monkey-patch on
+      # a core/stdlib/gem class is called cross-file (ADR-17). First
+      # write wins, matching `def_nodes`' own merge order.
+      #
       # @param paths  [Array<String>] project file paths.
       # @param buffer [Rigor::Analysis::BufferBinding, nil]
-      # @return [Hash{Symbol => Hash}] `{ def_nodes:, superclasses: }`
+      # @return [Hash{Symbol => Hash}]
+      #   `{ def_nodes:, def_sources:, superclasses:, includes: }`
       def discovered_def_index_for_paths(paths, buffer: nil)
-        def_nodes = {}
-        superclasses = {}
-        includes = {}
+        acc = { def_nodes: {}, def_sources: {}, superclasses: {}, includes: {}, method_visibilities: {}, methods: {} }
         paths.each do |path|
           physical = buffer ? buffer.resolve(path) : path
           root = Prism.parse(File.read(physical), filepath: path).value
-          build_discovered_def_nodes(root).each do |class_name, methods|
-            (def_nodes[class_name] ||= {}).merge!(methods)
-          end
-          superclasses.merge!(build_discovered_superclasses(root))
-          build_discovered_includes(root).each do |class_name, mods|
-            includes[class_name] = ((includes[class_name] || []) + mods).uniq
-          end
+          accumulate_project_index(acc, path, root)
         rescue StandardError
           # Skip files that fail to parse or read; the per-file
           # analyzer surfaces the parse error separately.
           next
         end
-        def_nodes.each_value(&:freeze)
-        includes.each_value(&:freeze)
-        { def_nodes: def_nodes.freeze, superclasses: superclasses.freeze, includes: includes.freeze }
+        # Cross-file method suppression is for the project's OWN
+        # accessors (attr_* / define_method / alias) — NOT for plain
+        # `def`s. A cross-file `def` on a class is exactly the ADR-17
+        # monkey-patch case the undefined-method rule deliberately
+        # surfaces (fire + def-site annotation, nudging `pre_eval:`),
+        # so dropping the `def`-declared names keeps that contract
+        # intact while still letting `attr_reader :x` in one file
+        # suppress a false undefined-method for `obj.x` in another.
+        acc[:methods] = subtract_def_methods(acc[:methods], acc[:def_nodes])
+        %i[def_nodes def_sources includes method_visibilities methods].each { |key| acc[key].each_value(&:freeze) }
+        acc.transform_values(&:freeze)
+      end
+
+      # Removes, per class, the method names that have a project `def`
+      # node, leaving only accessor/alias/define_method-introduced
+      # methods in the cross-file suppression table.
+      def subtract_def_methods(methods, def_nodes)
+        methods.each_with_object({}) do |(class_name, table), out|
+          defs = def_nodes[class_name] || {}
+          kept = table.reject { |method_name, _kind| defs.key?(method_name) }
+          out[class_name] = kept unless kept.empty?
+        end
+      end
+
+      # Folds one file's class-keyed indexes into the cross-file
+      # accumulator. `method_visibilities` (ADR-35) is collected here so
+      # the override-visibility-reduced rule can read an ancestor's
+      # visibility declared in a sibling file.
+      def accumulate_project_index(acc, path, root)
+        merge_discovered_defs(acc[:def_nodes], acc[:def_sources], path, root)
+        acc[:superclasses].merge!(build_discovered_superclasses(root))
+        build_discovered_includes(root).each do |class_name, mods|
+          acc[:includes][class_name] = ((acc[:includes][class_name] || []) + mods).uniq
+        end
+        build_discovered_method_visibilities(root).each do |class_name, table|
+          (acc[:method_visibilities][class_name] ||= {}).merge!(table)
+        end
+        build_discovered_methods(root).each do |class_name, table|
+          (acc[:methods][class_name] ||= {}).merge!(table)
+        end
+      end
+
+      # Merges one file's `class → method → DefNode` map into the
+      # cross-file `def_nodes` index and records each method's first-
+      # seen `"path:line"` definition site in `def_sources` (ADR-17 —
+      # the un-registered-project-patch signal `call.undefined-method`
+      # and `rigor triage` key on).
+      def merge_discovered_defs(def_nodes, def_sources, path, root)
+        build_discovered_def_nodes(root).each do |class_name, methods|
+          (def_nodes[class_name] ||= {}).merge!(methods)
+          sources = (def_sources[class_name] ||= {})
+          methods.each do |method_name, def_node|
+            sources[method_name] ||= "#{path}:#{def_node.location&.start_line || 1}"
+          end
+        end
       end
 
       # Class-only variant of `record_declarations` — descends

data/lib/rigor/inference/statement_evaluator.rb

@@ -1371,16 +1371,21 @@ module Rigor
         end
       end
 
-      # Walks the registry and collects each plugin's
-      # `flow_contribution_for` result, swallowing per-plugin
-      # exceptions so a buggy plugin can't abort the assertion
-      # path. Mirrors `MethodDispatcher.collect_plugin_contributions`
-      # exactly — the two paths consume the same hook.
+      # ADR-37 slice 2 — gathers each plugin's post-return narrowing from
+      # BOTH the narrow `type_specifier` DSL (method-gated, wrapped as a
+      # facts-only `FlowContribution`) and the legacy
+      # `flow_contribution_for` escape valve, swallowing per-plugin
+      # exceptions so a buggy plugin can't abort the assertion path.
       def collect_plugin_contributions(registry, call_node, current_scope)
-        registry.plugins.filter_map do |plugin|
-          plugin.flow_contribution_for(call_node: call_node, scope: current_scope)
+        registry.plugins.flat_map do |plugin|
+          contributions = []
+          legacy = plugin.flow_contribution_for(call_node: call_node, scope: current_scope)
+          contributions << legacy if legacy.is_a?(Rigor::FlowContribution)
+          facts = plugin.type_specifier_facts(call_node: call_node, scope: current_scope)
+          contributions << Rigor::FlowContribution.new(post_return_facts: facts) if facts && !facts.empty?
+          contributions
         rescue StandardError
-          nil
+          []
         end
       end
 

data/lib/rigor/inference/synthetic_method_index.rb

@@ -29,9 +29,19 @@ module Rigor
     # floor — the recorded string is the input to a later slice's
     # precision promotion via ADR-13's `Plugin::TypeNodeResolver`.
     class SyntheticMethodIndex
-      attr_reader :entries
+      attr_reader :entries, :class_names
 
-      def initialize(entries: [])
+      # @param entries [Array<SyntheticMethod>]
+      # @param class_names [Array<String>, Set<String>] names of
+      #   classes the substrate synthesises wholesale (ADR-36
+      #   nested-class emission — the variant subclasses that have
+      #   no RBS/source declaration of their own). Recorded so
+      #   `Environment#class_known?` can resolve them as classes
+      #   (their constant reference + `.new` dispatch) even though
+      #   nothing else in the type universe declares them. Tier B/C
+      #   method emissions leave this empty (their receiver classes
+      #   are already real).
+      def initialize(entries: [], class_names: [])
         unless entries.is_a?(Array) && entries.all?(SyntheticMethod)
           raise ArgumentError,
                 "SyntheticMethodIndex#entries must be an Array of SyntheticMethod, got #{entries.inspect}"
@@ -40,11 +50,20 @@ module Rigor
         @entries = Ractor.make_shareable(entries.dup)
         @by_instance = Ractor.make_shareable(bucket(entries, SyntheticMethod::INSTANCE))
         @by_singleton = Ractor.make_shareable(bucket(entries, SyntheticMethod::SINGLETON))
+        @class_names = Ractor.make_shareable(class_names.to_a.map(&:to_s).uniq.freeze)
+        @class_name_set = Ractor.make_shareable(@class_names.to_set)
         freeze
       end
 
       def empty?
-        entries.empty?
+        entries.empty? && class_names.empty?
+      end
+
+      # True when `name` is a substrate-synthesised class (an
+      # ADR-36 variant subclass). Used by `Environment#class_known?`
+      # so the constant resolves and `.new` dispatches.
+      def knows_class?(name)
+        @class_name_set.include?(name.to_s)
       end
 
       # Returns an Array of matching {SyntheticMethod} records in
@@ -59,7 +78,7 @@ module Rigor
       end
 
       def to_h
-        { "entries" => entries.map(&:to_h) }
+        { "entries" => entries.map(&:to_h), "class_names" => class_names }
       end
 
       EMPTY_ROW = [].freeze

data/lib/rigor/inference/synthetic_method_scanner.rb

@@ -4,6 +4,7 @@ require "prism"
 
 require_relative "../plugin/macro/heredoc_template"
 require_relative "../plugin/macro/trait_registry"
+require_relative "../source/literals"
 require_relative "synthetic_method"
 require_relative "synthetic_method_index"
 
@@ -69,13 +70,15 @@ module Rigor
       def scan(plugin_registry:, paths:, environment: nil, fact_store: nil, buffer: nil)
         templates = collect_templates(plugin_registry)
         registries = collect_trait_registries(plugin_registry)
-        return SyntheticMethodIndex::EMPTY if templates.empty? && registries.empty?
+        nested_templates = collect_nested_class_templates(plugin_registry)
+        return SyntheticMethodIndex::EMPTY if templates.empty? && registries.empty? && nested_templates.empty?
 
         asts = parse_paths(paths, buffer: buffer)
         hierarchy = build_hierarchy(asts)
         concern_index = build_concern_index(asts)
 
         entries = []
+        class_names = []
         asts.each do |path, ast|
           walk_class_bodies(ast) do |class_name, call_node|
             collect_entries(entries, templates, class_name, call_node, hierarchy, environment, path, fact_store)
@@ -85,9 +88,10 @@ module Rigor
               templates, registries, hierarchy, environment, path, fact_store
             )
           end
+          collect_nested_class_entries(entries, class_names, nested_templates, ast, path) unless nested_templates.empty?
         end
 
-        SyntheticMethodIndex.new(entries: entries)
+        SyntheticMethodIndex.new(entries: entries, class_names: class_names)
       end
 
       # Aggregates `(plugin_id, template)` pairs across every
@@ -119,6 +123,146 @@ module Rigor
         end
       end
 
+      # ADR-36 — aggregates `(plugin_id, template)` pairs across
+      # every plugin's `manifest.nested_class_templates`. Empty when
+      # no plugin contributes the nested-class emission tier.
+      def collect_nested_class_templates(plugin_registry)
+        return [] if plugin_registry.nil? || plugin_registry.empty?
+
+        plugin_registry.plugins.flat_map do |plugin|
+          # rigor:disable undefined-method
+          plugin.manifest.nested_class_templates.map do |template|
+            [plugin.manifest.id, template]
+          end
+        end
+      end
+
+      # ADR-36 nested-class emission. For each class that `extend`s a
+      # template's `receiver_constraint` and carries a
+      # `<block_method> do ... end` block, mint one synthetic
+      # subclass per `<variant_method> <Const>, <Type>` row:
+      #
+      #   class Shape
+      #     extend Mangrove::Enum
+      #     variants do
+      #       variant Circle, Float
+      #     end
+      #   end
+      #
+      # yields synthetic class `Shape::Circle` + instance method
+      # `Shape::Circle#inner -> Float`. The variant subclass name is
+      # recorded in `class_names` so `Environment#class_known?`
+      # resolves the constant (and `.new` dispatches through
+      # `meta_new`); `#inner`'s return type is the literal constant
+      # type argument (non-constant inner shapes degrade to
+      # `Dynamic[Top]` per the slice-A floor).
+      def collect_nested_class_entries(entries, class_names, nested_templates, ast, path)
+        return if ast.nil?
+
+        walk_classes(ast) do |class_name, class_node|
+          body = class_body_statements(class_node)
+          next if body.empty?
+
+          nested_templates.each do |(plugin_id, template)|
+            next unless body_extends?(body, template.receiver_constraint)
+
+            each_variant_call(body, template) do |variant_const, inner_node|
+              emit_variant(entries, class_names, class_name, variant_const, inner_node, template, plugin_id, path)
+            end
+          end
+        end
+      end
+
+      # Walks every class declaration, yielding its fully-qualified
+      # name and the `Prism::ClassNode`. Mirrors `walk_class_bodies`'
+      # scope-stack bookkeeping but hands back the class node itself.
+      def walk_classes(node, scope_stack = [], &)
+        return unless node.respond_to?(:compact_child_nodes)
+
+        case node
+        when Prism::ClassNode
+          name = class_name_from(node, scope_stack)
+          yield name, node if name
+          new_stack = scope_stack + [node]
+          node.body&.compact_child_nodes&.each { |child| walk_classes(child, new_stack, &) }
+        when Prism::ModuleNode
+          new_stack = scope_stack + [node]
+          node.body&.compact_child_nodes&.each { |child| walk_classes(child, new_stack, &) }
+        else
+          node.compact_child_nodes.each { |child| walk_classes(child, scope_stack, &) }
+        end
+      end
+
+      def class_body_statements(class_node)
+        body = class_node.body
+        body.respond_to?(:body) ? body.body.compact : []
+      end
+
+      # True when the class body carries `extend <constraint>`
+      # (receiverless `extend` call with the constraint constant as
+      # its first argument).
+      def body_extends?(body, constraint)
+        body.any? do |stmt|
+          stmt.is_a?(Prism::CallNode) && stmt.receiver.nil? && stmt.name == :extend &&
+            const_name_string(first_arg(stmt)) == constraint
+        end
+      end
+
+      # Yields `(variant_const_name, inner_type_node)` for every
+      # `<variant_method> <Const>, <Type>` call inside the template's
+      # `<block_method> do ... end` block(s).
+      def each_variant_call(body, template, &)
+        body.each do |stmt|
+          next unless variants_block_call?(stmt, template)
+
+          block_body_statements(stmt.block).each { |call| yield_variant(call, template, &) }
+        end
+      end
+
+      def variants_block_call?(stmt, template)
+        stmt.is_a?(Prism::CallNode) && stmt.receiver.nil? &&
+          stmt.name == template.block_method && stmt.block.is_a?(Prism::BlockNode)
+      end
+
+      def yield_variant(call, template)
+        return unless call.is_a?(Prism::CallNode) && call.receiver.nil? && call.name == template.variant_method
+
+        args = call.arguments&.arguments || []
+        variant_const = const_name_string(args[template.name_arg_position])
+        return if variant_const.nil?
+
+        yield variant_const, args[template.inner_arg_position]
+      end
+
+      def block_body_statements(block_node)
+        body = block_node.body
+        body.respond_to?(:body) ? body.body.compact : []
+      end
+
+      def emit_variant(entries, class_names, enclosing, variant_const, inner_node, template, plugin_id, path) # rubocop:disable Metrics/ParameterLists
+        variant_class = "#{enclosing}::#{variant_const}"
+        class_names << variant_class
+        inner_type = const_name_string(inner_node) || "untyped"
+
+        entries << SyntheticMethod.new(
+          class_name: variant_class,
+          method_name: template.inner_reader,
+          return_type: inner_type,
+          kind: SyntheticMethod::INSTANCE,
+          provenance: {
+            plugin_id: plugin_id,
+            tier: "nested_class",
+            enclosing: enclosing,
+            variant: variant_const,
+            source_path: path
+          }
+        )
+      end
+
+      def first_arg(call_node)
+        call_node.arguments&.arguments&.first
+      end
+
       def parse_paths(paths, buffer: nil)
         paths.to_h do |path|
           physical = buffer ? buffer.resolve(path) : path
@@ -399,9 +543,7 @@ module Rigor
       end
 
       def literal_symbol_value(node)
-        case node
-        when Prism::SymbolNode, Prism::StringNode then node.unescaped.to_sym
-        end
+        Source::Literals.symbol_or_string(node)
       end
 
       def emit_trait_module_entries(entries, class_name, modules, registry, plugin_id, path, call_node, environment) # rubocop:disable Metrics/ParameterLists
@@ -584,15 +726,7 @@ module Rigor
       end
 
       def literal_symbol_arg(call_node, index)
-        args_node = call_node.arguments
-        return nil if args_node.nil?
-
-        arg = args_node.arguments[index]
-        return nil unless arg
-
-        case arg
-        when Prism::SymbolNode, Prism::StringNode then arg.unescaped.to_sym
-        end
+        Source::Literals.symbol_arg(call_node, index)
       end
     end
   end