rigortype 0.2.9 → 0.3.0

data/lib/rigor/source/node_children.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require "prism"
+
+module Rigor
+  module Source
+    # Allocation-free replacement for the `node.compact_child_nodes.each { … }` idiom.
+    #
+    # `Prism::Node#compact_child_nodes` allocates a fresh Array on every call — for the ~43 leaf node classes
+    # (`IntegerNode`, `LocalVariableReadNode`, `NilNode`, …) it is literally `def compact_child_nodes; []; end`.
+    # Rigor's tree walkers call it unconditionally on every node of every walk, so one full-tree walk allocates one
+    # Array per node visited. On leaf-heavy sources (a Ragel-generated parser has hundreds of thousands of
+    # integer-literal leaves) these throwaway arrays are the single largest allocation source in a run — over half
+    # of all allocations on mail's `lib`.
+    #
+    # Loading this file compiles a `#rigor_each_child` method onto every `Prism::*Node` class (additive reopening of
+    # a dependency's class, the `Cache::RbsEnvironmentMarshalPatch` precedent; the `rigor_` prefix keeps it
+    # collision-free). It yields the same child nodes, in the same order, without materialising the intermediate
+    # array: each child-bearing field is read directly in field declaration order — exactly the order
+    # `compact_child_nodes` emits — and a `NodeListField`'s already-materialised array is iterated in place (the
+    # reader returns the stored array, not a copy). Nil optional children and nil list elements are skipped,
+    # mirroring `compact_child_nodes`'s "compact" semantics. Leaf classes compile to an empty method.
+    #
+    # A method compiled onto the node class is the fastest dispatch available for this shape — one virtual send on
+    # the receiver, the same mechanism `compact_child_nodes` itself uses, with zero allocation. The reflective
+    # alternatives were measured and rejected: a `public_send`-per-field loop is ~45 % *slower* than
+    # `compact_child_nodes` on a full-tree walk (dynamic dispatch per field swamps the allocation win), and a
+    # central generated-method table dispatched via `Module#send` + a per-class Hash lookup still regressed
+    # Rails-corpus wall ~5 % under YJIT. Walkers therefore call `node.rigor_each_child { … }` directly.
+    #
+    # The field map is derived once at load from `Prism::Reflection`, so it tracks whatever `prism` version resolves
+    # at runtime (ADR-79) instead of a hand-maintained table. `spec/rigor/source/node_children_spec.rb` is the
+    # binding contract: over a corpus of real source it asserts — for every node reached — that both
+    # `#rigor_each_child` and {each_child} yield output element-for-element identical (object identity and order) to
+    # `compact_child_nodes`.
+    module NodeChildren
+      module_function
+
+      # The concrete `Prism::*Node` classes (`< Prism::Node`).
+      NODE_CLASSES =
+        Prism.constants.grep(/Node\z/).filter_map do |name|
+          const = Prism.const_get(name)
+          const if const.is_a?(Class) && const < Prism::Node
+        end.freeze
+
+      # Shared frozen empty entry for leaf classes. Identity (`equal?`) distinguishes a leaf entry from a
+      # childless-in-practice non-leaf.
+      EMPTY = [].freeze
+
+      # node class => frozen Array of `[reader_symbol, :node | :node_optional | :list]` pairs, in field declaration
+      # order (the order `compact_child_nodes` emits its children). Leaf classes map to {EMPTY}. This is the source
+      # of truth the per-class methods are compiled from, exposed for introspection and the equivalence spec.
+      CHILD_READERS =
+        NODE_CLASSES.each_with_object({}) do |klass, map|
+          pairs = Prism::Reflection.fields_for(klass).filter_map do |field|
+            case field
+            when Prism::Reflection::OptionalNodeField
+              [field.name, :node_optional].freeze
+            when Prism::Reflection::NodeField
+              [field.name, :node].freeze
+            when Prism::Reflection::NodeListField
+              [field.name, :list].freeze
+            end
+          end
+          map[klass] = pairs.empty? ? EMPTY : pairs.freeze
+        end.freeze
+
+      # The leaf classes — no child-bearing field, so `compact_child_nodes` is always `[]` and `#rigor_each_child`
+      # compiles to an empty method. Exposed for the equivalence spec and introspection.
+      LEAF_CLASSES = NODE_CLASSES.select { |klass| CHILD_READERS[klass].equal?(EMPTY) }.to_set.freeze
+
+      # Codegen (not per-call reflection) so iteration reads fields directly at hand-written speed — see the module
+      # comment for the measurements ruling out the reflective forms. Each statement mirrors `compact_child_nodes`'s
+      # own form for that field kind exactly: a required `NodeField` is yielded unconditionally (`compact <<
+      # predicate`), an `OptionalNodeField` behind a truthiness guard (`compact << receiver if receiver`), and a
+      # `NodeListField`'s stored array is iterated unfiltered (`compact.concat(requireds)`) — no extra nil checks
+      # beyond what Prism itself performs. The explicit `self.` receiver keeps a hypothetical future field named
+      # `child` from parsing as the just-assigned local. For a `CallNode` (three optional-node fields) the emitted
+      # source is:
+      #
+      #   def rigor_each_child
+      #     child = self.receiver
+      #     yield child if child
+      #     child = self.arguments
+      #     yield child if child
+      #     child = self.block
+      #     yield child if child
+      #   end
+      NODE_CLASSES.each do |klass|
+        statements = CHILD_READERS[klass].map do |reader, kind|
+          case kind
+          when :list          then "self.#{reader}.each { |child| yield child }"
+          when :node_optional then "child = self.#{reader}\n  yield child if child"
+          else                     "yield self.#{reader}"
+          end
+        end
+        klass.class_eval(<<~RUBY, __FILE__, __LINE__ + 1) # rubocop:disable Style/DocumentDynamicEvalDefinition
+          def rigor_each_child
+            #{statements.join("\n  ")}
+          end
+        RUBY
+      end
+
+      # Yield each direct child `Prism::Node` of `node` in `compact_child_nodes` order, without allocating an
+      # intermediate array. Nil / non-node input yields nothing (an optional field can be nil, so a caller may pass
+      # e.g. `node.body`). Pure and re-entrant; `break` / `next` / `return` in the block behave exactly as they
+      # would with `compact_child_nodes.each`. Walkers holding a known `Prism::Node` call `#rigor_each_child`
+      # directly; this wrapper is the nil-tolerant entry.
+      #
+      # @yieldparam child [Prism::Node]
+      def each_child(node, &)
+        node.rigor_each_child(&) if node.is_a?(Prism::Node)
+      end
+    end
+  end
+end

data/lib/rigor/source/node_locator.rb

@@ -2,6 +2,8 @@
 
 require "prism"
 
+require_relative "node_children"
+
 module Rigor
   module Source
     # Locates the deepest Prism AST node enclosing a given source position.
@@ -83,7 +85,7 @@ module Rigor
         return nil unless node.is_a?(Prism::Node)
         return nil unless contains?(node, offset)
 
-        node.compact_child_nodes.each do |child|
+        node.rigor_each_child do |child|
           deeper = descend(child, offset)
           return deeper if deeper
         end

data/lib/rigor/source/node_walker.rb

@@ -2,6 +2,8 @@
 
 require "prism"
 
+require_relative "node_children"
+
 module Rigor
   module Source
     # Yields every `Prism::Node` reachable from a root in DFS pre-order.
@@ -28,7 +30,7 @@ module Rigor
         return unless node.is_a?(Prism::Node)
 
         yield node
-        node.compact_child_nodes.each { |child| walk(child, &) }
+        node.rigor_each_child { |child| walk(child, &) }
       end
 
       # Like {.each}, but also yields the node's lexical ancestor chain (outermost first, EXCLUDING the node
@@ -51,7 +53,7 @@ module Rigor
 
         block.call(node, ancestors)
         ancestors.push(node)
-        node.compact_child_nodes.each { |child| walk_with_ancestors(child, ancestors, &block) }
+        node.rigor_each_child { |child| walk_with_ancestors(child, ancestors, &block) }
         ancestors.pop
       end
     end

data/lib/rigor/source.rb

@@ -10,6 +10,7 @@ module Rigor
   end
 end
 
+require_relative "source/node_children"
 require_relative "source/node_locator"
 require_relative "source/node_walker"
 require_relative "source/literals"

data/lib/rigor/type/difference.rb

@@ -48,6 +48,30 @@ module Rigor
         base.erase_to_rbs
       end
 
+      # True when `removed` is the *empty witness* of `base` — the single value whose removal makes this
+      # difference one of the catalogued `non-empty-*` / `non-zero-int` refinements (`""` for String, `0`
+      # for Integer, `[]` for Array, `{}` for Hash).
+      #
+      # This is the shared recogniser for the whole engine: the display side (`canonical_name` below),
+      # `ShapeDispatch`'s refinement-aware projections, and `MutationWidening`'s invalidation arm all ask
+      # this one question, so the recognised set cannot drift between them.
+      def removes_empty_witness?
+        return false unless base.is_a?(Nominal)
+
+        predicate = EMPTY_WITNESS_PREDICATES[base.class_name]
+        !!predicate && predicate.call(removed)
+      end
+
+      EMPTY_WITNESS_PREDICATES = {
+        "String" => ->(removed) { removed.is_a?(Constant) && removed.value == "" },
+        "Integer" => lambda { |removed|
+          removed.is_a?(Constant) && removed.value.is_a?(Integer) && removed.value.zero?
+        },
+        "Array" => ->(removed) { removed.is_a?(Tuple) && removed.elements.empty? },
+        "Hash" => ->(removed) { removed.is_a?(HashShape) && removed.pairs.empty? }
+      }.freeze
+      private_constant :EMPTY_WITNESS_PREDICATES
+
       def top
         Trinary.no
       end
@@ -80,47 +104,27 @@ module Rigor
       # The recognised set is kept in sync with the imported-built-in catalogue
       # ([`imported-built-in-types.md`](docs/type-specification/imported-built-in-types.md)).
       def canonical_name
-        return nil unless base.is_a?(Nominal)
+        return nil unless removes_empty_witness?
 
-        send(CANONICAL_HANDLERS[base.class_name] || :no_canonical_name)
+        send(CANONICAL_HANDLERS[base.class_name])
       end
 
       CANONICAL_HANDLERS = {
         "String" => :string_canonical_name,
         "Integer" => :integer_canonical_name,
-        "Array" => :array_canonical_name_if_empty,
-        "Hash" => :hash_canonical_name_if_empty
+        "Array" => :array_canonical_name,
+        "Hash" => :hash_canonical_name
       }.freeze
       private_constant :CANONICAL_HANDLERS
 
-      def no_canonical_name
-        nil
-      end
-
       def string_canonical_name
-        return nil unless removed.is_a?(Constant) && removed.value == ""
-
         "non-empty-string"
       end
 
       def integer_canonical_name
-        return nil unless removed.is_a?(Constant) && removed.value.is_a?(Integer) && removed.value.zero?
-
         "non-zero-int"
       end
 
-      def array_canonical_name_if_empty
-        return nil unless removed.is_a?(Tuple) && removed.elements.empty?
-
-        array_canonical_name
-      end
-
-      def hash_canonical_name_if_empty
-        return nil unless removed.is_a?(HashShape) && removed.pairs.empty?
-
-        hash_canonical_name
-      end
-
       def array_canonical_name
         elem = base.type_args.first
         return "non-empty-array" if elem.nil?

data/lib/rigor/type/hash_shape.rb

@@ -11,9 +11,12 @@ module Rigor
     # inhabit the corresponding value types. RBS records correspond to the exact closed subset; Rigor
     # extends that carrier with optional keys, read-only entry views, and an open/closed extra-key policy.
     #
-    # Keys are restricted to Symbol and String values. Exact closed symbol-keyed shapes erase to the RBS
-    # record syntax `{ a: Integer, ?b: String }`; all other shapes degrade to `Hash[K, V]` or raw `Hash`
-    # when no useful bounds are available.
+    # Keys are restricted to value-pinned scalar literals: Symbol, String, Integer, Float, and the
+    # `true` / `false` / `nil` singletons. Exact closed symbol-keyed shapes erase to the RBS record
+    # syntax `{ a: Integer, ?b: String }`; all other shapes degrade to `Hash[K, V]` or raw `Hash` when
+    # no useful bounds are available. Key identity follows Ruby's own `Hash` `eql?` semantics because
+    # the pairs are stored in a native Ruby Hash — `1` and `1.0` are DISTINCT keys (`1.eql?(1.0)` is
+    # false), while `1.0` and `1.00` are the same key.
     #
     # Equality and hashing are structural over the (key -> Rigor::Type) pair set and policy fields. Hash
     # insertion order is preserved by the underlying storage but does NOT affect equality (matching
@@ -22,7 +25,7 @@ module Rigor
     # See docs/type-specification/rbs-compatible-types.md (records) and
     # docs/type-specification/rigor-extensions.md (hash shape).
     class HashShape
-      ALLOWED_KEY_CLASSES = [Symbol, String].freeze
+      ALLOWED_KEY_CLASSES = [Symbol, String, Integer, Float, TrueClass, FalseClass, NilClass].freeze
       EXTRA_KEY_POLICIES = %i[open closed].freeze
       POLICY_KEYWORDS = %i[required_keys optional_keys read_only_keys extra_keys].freeze
       # A Symbol whose text matches renders as a bare RBS record key (`lang:`) in {#erase_to_rbs};
@@ -128,7 +131,8 @@ module Rigor
         pairs.each_key do |key|
           next if ALLOWED_KEY_CLASSES.any? { |klass| key.is_a?(klass) }
 
-          raise ArgumentError, "HashShape keys must be Symbol or String, got #{key.class}"
+          raise ArgumentError,
+                "HashShape keys must be one of #{ALLOWED_KEY_CLASSES.join(', ')}, got #{key.class}"
         end
       end
 
@@ -190,17 +194,28 @@ module Rigor
         prefix = []
         prefix << "readonly" if read_only_key?(key)
         rendered_key = optional_key?(key) ? "?#{render_key(key)}" : render_key(key)
-        prefix << "#{rendered_key}:"
+        prefix << "#{rendered_key}#{key_separator(key)}"
         "#{prefix.join(' ')} #{value.describe(verbosity)}"
       end
 
       # `describe` is a human-facing display contract (it feeds diagnostic messages, never a parser),
-      # so it keeps the compact `"a":` form for a quoted key. The RBS-erasure path uses
-      # {#erase_key_prefix} instead, which must emit a parseable key.
+      # so it keeps the compact `"a":` form for a quoted key. Non-(Symbol|String) scalar keys render in
+      # the natural hashrocket spelling (`1 => 2`, `1.0 => 4`, `nil => 0`) via {#key_separator}; their
+      # `inspect` is the canonical Ruby literal, so describe stays deterministic. The RBS-erasure path
+      # uses {#erase_key_prefix} instead, which must emit a parseable key.
       def render_key(key)
         case key
         when Symbol then key.to_s
-        when String then key.inspect
+        else key.inspect
+        end
+      end
+
+      # Symbol / String keys keep the compact colon form (`a: 1`, `"k": 2`); every other scalar key uses
+      # the hashrocket (`1 => 2`) — the form the user would have to write in source.
+      def key_separator(key)
+        case key
+        when Symbol, String then ":"
+        else " =>"
         end
       end
 
@@ -230,8 +245,17 @@ module Rigor
         "Hash[#{key_type.erase_to_rbs}, #{value_type.erase_to_rbs}]"
       end
 
+      # Conservative per-key-class bound for the `Hash[K, V]` degradation. Symbol / String / Integer /
+      # Float keys widen to their class nominal; the `true` / `false` / `nil` singletons keep their
+      # literal carrier (the constant IS the class's whole value set, and RBS spells the literal — `nil`
+      # reads better than `NilClass`).
       def hash_erasure_key_type
-        key_types = pairs.keys.map { |key| Type::Combinator.nominal_of(key.class) }
+        key_types = pairs.keys.map do |key|
+          case key
+          when true, false, nil then Type::Combinator.constant_of(key)
+          else Type::Combinator.nominal_of(key.class)
+          end
+        end
         Type::Combinator.union(*key_types)
       end
     end

data/lib/rigor/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Rigor
-  VERSION = "0.2.9"
+  VERSION = "0.3.0"
 end

data/lib/rigortype.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+# Nothing in an application should ever load Rigor: it is a command-line tool
+# that reads a project from the outside, not a library (ADR-27). This file
+# exists only because `Bundler.require` — the default for every Gemfile entry,
+# and what Rails runs at boot — requires a gem by its *gem* name, `rigortype`,
+# while the library entry point is `rigor.rb`.
+#
+# Without this file that call raises a bare `LoadError` naming `rigortype`, so
+# a `bundle add rigortype` succeeds and the *next* `rails s` dies with no
+# explanation of what went wrong or what to do instead. The file is a guardrail,
+# not an entry point: it warns and defines nothing. `require "rigor"` remains
+# the (analyzer-internal) way in.
+warn(<<~MESSAGE)
+  rigortype: `require "rigortype"` does nothing — Rigor is a command-line tool, not a library.
+
+  This usually means Rigor is in your Gemfile, where `Bundler.require` loads it at boot. Rigor
+  analyses your project from the outside and runs on its own Ruby, so a Gemfile entry constrains
+  your application's Ruby and dependency resolution without giving you anything. Remove it and
+  install Rigor independently: https://github.com/rigortype/rigor/blob/master/docs/install.md
+
+  To keep the Gemfile entry anyway, mark it `gem "rigortype", require: false` — that silences
+  this warning, but the resolution constraints remain.
+MESSAGE

data/plugins/rigor-actioncable/lib/rigor/plugin/actioncable/channel_discoverer.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "rigor/source/node_children"
+
 require "prism"
 
 require_relative "channel_index"
@@ -76,7 +78,7 @@ module Rigor
           when Prism::ClassNode then visit_class(node, lexical_path, &)
           when Prism::ModuleNode then visit_module(node, lexical_path, &)
           else
-            node.compact_child_nodes.each { |child| walk_for_channels(child, lexical_path, &) }
+            node.rigor_each_child { |child| walk_for_channels(child, lexical_path, &) }
           end
         end
 
@@ -138,7 +140,7 @@ module Rigor
             end
           end
 
-          node.compact_child_nodes.each do |child|
+          node.rigor_each_child do |child|
             names, dynamic = collect_stream_registrations(child, names: names, dynamic: dynamic)
           end
           [names, dynamic]

data/plugins/rigor-actionmailer/lib/rigor/plugin/actionmailer/mailer_discoverer.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "rigor/source/node_children"
+
 require "prism"
 require "rigor/source/literals"
 
@@ -97,7 +99,7 @@ module Rigor
           when Prism::ClassNode then visit_class(node, lexical_path, &)
           when Prism::ModuleNode then visit_module(node, lexical_path, &)
           else
-            node.compact_child_nodes.each { |child| walk_for_mailers(child, lexical_path, &) }
+            node.rigor_each_child { |child| walk_for_mailers(child, lexical_path, &) }
           end
         end
 
@@ -124,7 +126,7 @@ module Rigor
           return [] if body.nil?
 
           names = []
-          body.compact_child_nodes.each do |node|
+          body.rigor_each_child do |node|
             next unless node.is_a?(Prism::CallNode) && node.receiver.nil? && node.name == :include
 
             (node.arguments&.arguments || []).each do |arg|
@@ -158,7 +160,7 @@ module Rigor
             inner = local_name ? lexical_path + [local_name.delete_prefix("::")] : lexical_path
             collect_module_actions(node.body, inner, accumulator) if node.body
           else
-            node.compact_child_nodes.each { |child| collect_module_actions(child, lexical_path, accumulator) }
+            node.rigor_each_child { |child| collect_module_actions(child, lexical_path, accumulator) }
           end
         end
 
@@ -231,7 +233,7 @@ module Rigor
           private_names = []
           callback_names = []
 
-          body.compact_child_nodes.each do |node|
+          body.rigor_each_child do |node|
             next unless node.is_a?(Prism::CallNode) && node.receiver.nil?
 
             args = (node.arguments&.arguments || []).filter_map do |arg|

data/plugins/rigor-actionpack/lib/rigor/plugin/actionpack/controller_discoverer.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "rigor/source/node_children"
+
 require "prism"
 
 require_relative "controller_index"
@@ -89,7 +91,7 @@ module Rigor
 
             walk_declarations(node.body, namespace: inner_namespace, &)
           else
-            node.compact_child_nodes.each do |child|
+            node.rigor_each_child do |child|
               walk_declarations(child, namespace: namespace, &)
             end
           end
@@ -142,7 +144,7 @@ module Rigor
           return accumulator unless node.is_a?(Prism::Node)
 
           accumulator << node.name if node.is_a?(Prism::DefNode) && node.receiver.nil?
-          node.compact_child_nodes.each { |child| collect_def_names(child, accumulator) }
+          node.rigor_each_child { |child| collect_def_names(child, accumulator) }
           accumulator
         end
 
@@ -160,7 +162,7 @@ module Rigor
             end
           end
 
-          node.compact_child_nodes.each { |child| collect_include_targets(child, accumulator) }
+          node.rigor_each_child { |child| collect_include_targets(child, accumulator) }
           accumulator
         end
 

data/plugins/rigor-activejob/lib/rigor/plugin/activejob/job_discoverer.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "rigor/source/node_children"
+
 require "prism"
 
 require_relative "job_index"
@@ -66,7 +68,7 @@ module Rigor
           when Prism::ClassNode then visit_class(node, lexical_path, &)
           when Prism::ModuleNode then visit_module(node, lexical_path, &)
           else
-            node.compact_child_nodes.each { |child| walk_for_jobs(child, lexical_path, &) }
+            node.rigor_each_child { |child| walk_for_jobs(child, lexical_path, &) }
           end
         end
 
@@ -118,7 +120,7 @@ module Rigor
         def lookup_perform_def(body)
           return nil if body.nil?
 
-          body.compact_child_nodes.each do |node|
+          body.rigor_each_child do |node|
             next unless node.is_a?(Prism::DefNode) && node.name == :perform
             next if node.receiver.is_a?(Prism::SelfNode)
 

data/plugins/rigor-activerecord/lib/rigor/plugin/activerecord/analyzer.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "rigor/source/node_children"
+
 require "prism"
 
 module Rigor
@@ -50,7 +52,7 @@ module Rigor
           return if node.nil?
 
           yield node
-          node.compact_child_nodes.each { |child| walk(child, &) }
+          node.rigor_each_child { |child| walk(child, &) }
         end
 
         def visit_call(node)

data/plugins/rigor-activerecord/lib/rigor/plugin/activerecord/model_discoverer.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "rigor/source/node_children"
+
 require "prism"
 require "rigor/source/literals"
 
@@ -140,7 +142,7 @@ module Rigor
           when Prism::ModuleNode
             visit_module(node, lexical_path, &)
           else
-            node.compact_child_nodes.each { |child| walk_for_classes(child, lexical_path, &) }
+            node.rigor_each_child { |child| walk_for_classes(child, lexical_path, &) }
           end
         end
 
@@ -256,7 +258,7 @@ module Rigor
         def lookup_table_name_override(body)
           return nil if body.nil?
 
-          body.compact_child_nodes.each do |node|
+          body.rigor_each_child do |node|
             next unless node.is_a?(Prism::CallNode) && node.name == :table_name=
             next unless node.receiver.is_a?(Prism::SelfNode)
 

data/plugins/rigor-activerecord/lib/rigor/plugin/activerecord/schema_parser.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "rigor/source/node_children"
+
 require "prism"
 
 module Rigor
@@ -66,7 +68,7 @@ module Rigor
 
           yield node if node.is_a?(Prism::CallNode) && node.name == :create_table && node.receiver.nil?
 
-          node.compact_child_nodes.each { |child| collect_create_table_calls(child, &) }
+          node.rigor_each_child { |child| collect_create_table_calls(child, &) }
         end
 
         def parse_create_table(call_node)
@@ -118,7 +120,7 @@ module Rigor
             return
           end
 
-          node.compact_child_nodes.each { |child| collect_column_calls(child, &) }
+          node.rigor_each_child { |child| collect_column_calls(child, &) }
         end
 
         def parse_column(call_node)

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

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "rigor/source/node_children"
+
 require "prism"
 
 module Rigor
@@ -32,7 +34,7 @@ module Rigor
           return if node.nil?
 
           yield node
-          node.compact_child_nodes.each { |child| walk(child, &) }
+          node.rigor_each_child { |child| walk(child, &) }
         end
 
         def visit_call(node)

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

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "rigor/source/node_children"
+
 require "prism"
 require "rigor/source/literals"
 
@@ -77,7 +79,7 @@ module Rigor
           when Prism::ModuleNode
             visit_module(node, lexical_path, &)
           else
-            node.compact_child_nodes.each { |child| walk(child, lexical_path, &) }
+            node.rigor_each_child { |child| walk(child, lexical_path, &) }
           end
         end
 
@@ -105,7 +107,7 @@ module Rigor
           return [] if body.nil?
 
           rows = []
-          body.compact_child_nodes.each do |node|
+          body.rigor_each_child do |node|
             next unless node.is_a?(Prism::CallNode)
 
             kind = ATTACHMENT_METHODS[node.name]