rigortype 0.1.2 → 0.1.4

data/lib/rigor/inference/method_dispatcher/rbs_dispatch.rb

@@ -162,7 +162,8 @@ module Rigor
               kind: kind,
               args: args,
               type_vars: type_vars,
-              block_type: block_type
+              block_type: block_type,
+              environment: environment
             )
           rescue StandardError
             # Defensive: if RBS' definition builder raises on a broken
@@ -194,6 +195,18 @@ module Rigor
               ["Array", :instance, tuple_type_args(receiver)]
             when Type::HashShape
               ["Hash", :instance, hash_shape_type_args(receiver)]
+            when Type::BoundMethod
+              # `BoundMethod` is a precision-bearing alias for
+              # `Nominal[Method]`: it carries the
+              # `(receiver, method_name)` binding that
+              # `MethodFolding.try_backward` consumes at
+              # `.call` / `.()` / `[]`, but every other call
+              # site (`.owner` / `.name` / `.arity` / …) must
+              # still resolve through Method's RBS contract.
+              # Routing here keeps reflective Method methods
+              # working without forcing the carrier to
+              # collapse to a plain Nominal at construction.
+              ["Method", :instance, []]
             when Type::Dynamic
               receiver_descriptor(receiver.static_facet)
             end
@@ -241,15 +254,15 @@ module Rigor
             param_names.zip(receiver_args).to_h
           end
 
-          # rubocop:disable Metrics/ParameterLists
-          def translate_return_type(method_definition, class_name:, kind:, args:, type_vars:, block_type:)
+          def translate_return_type(method_definition, class_name:, kind:, args:, type_vars:, block_type:,
+                                    environment: nil)
             # Slice 4b-3 (ADR-7 § "Slice 4-A/4-B") — read the
             # return-type override through the merger so future
             # plugin / `:rbs_extended` bundles that also assert a
             # `return_type` slot at this call site compose with
             # the RBS::Extended directive instead of silently
             # racing it.
-            override = merged_return_type(method_definition)
+            override = merged_return_type(method_definition, environment: environment)
             return override if override
 
             instance_type = Type::Combinator.nominal_of(class_name)
@@ -265,7 +278,8 @@ module Rigor
               self_type: self_type,
               instance_type: instance_type,
               type_vars: type_vars,
-              block_required: !block_type.nil?
+              block_required: !block_type.nil?,
+              environment: environment
             )
             return nil unless method_type
 
@@ -278,7 +292,6 @@ module Rigor
               type_vars: full_type_vars
             )
           end
-          # rubocop:enable Metrics/ParameterLists
 
           # ADR-7 § "Slice 4-A/4-B" — folds the
           # `RBS::Extended` `return:` directive (and any
@@ -287,8 +300,8 @@ module Rigor
           # before consuming. Returns the merged return type
           # or nil when no contribution overrides the
           # RBS-declared return.
-          def merged_return_type(method_definition)
-            contribution = RbsExtended.read_flow_contribution(method_definition)
+          def merged_return_type(method_definition, environment: nil)
+            contribution = RbsExtended.read_flow_contribution(method_definition, environment: environment)
             return nil if contribution.nil?
 
             Rigor::FlowContribution::Merger.merge([contribution]).return_type
@@ -377,13 +390,15 @@ module Rigor
               class_name: class_name,
               kind: kind,
               args: args,
-              type_vars: type_vars
+              type_vars: type_vars,
+              environment: environment
             )
           rescue StandardError
             []
           end
 
-          def extract_block_param_types(method_definition, class_name:, kind:, args:, type_vars:)
+          def extract_block_param_types(method_definition, class_name:, kind:, args:, type_vars:,
+                                        environment: nil)
             instance_type = Type::Combinator.nominal_of(class_name)
             self_type =
               case kind
@@ -397,7 +412,8 @@ module Rigor
               self_type: self_type,
               instance_type: instance_type,
               type_vars: type_vars,
-              block_required: true
+              block_required: true,
+              environment: environment
             )
             return [] unless method_type
 

data/lib/rigor/inference/method_dispatcher/shape_dispatch.rb

@@ -626,7 +626,6 @@ module Rigor
           # (so it can serve as a Hash key). Produces a closed
           # `HashShape` whose entries mirror the per-position
           # pairs. Empty Tuples fold to the empty HashShape.
-          # rubocop:disable Metrics/CyclomaticComplexity
           def tuple_to_h(tuple, _method_name, args)
             return nil unless args.empty?
             return Type::Combinator.hash_shape_of({}) if tuple.elements.empty?
@@ -637,7 +636,6 @@ module Rigor
 
             Type::Combinator.hash_shape_of(pairs.to_h)
           end
-          # rubocop:enable Metrics/CyclomaticComplexity
 
           def tuple_to_h_pair(element)
             return nil unless element.is_a?(Type::Tuple)
@@ -865,7 +863,6 @@ module Rigor
           # `HashShape` accepts as keys). Duplicate values would
           # alias under inversion, so Rigor declines on
           # collisions rather than silently dropping entries.
-          # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
           def hash_invert(shape, _method_name, args)
             return nil unless args.empty?
             return nil unless shape.closed?
@@ -880,7 +877,6 @@ module Rigor
             end
             Type::Combinator.hash_shape_of(inverted)
           end
-          # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
           # `shape.first` — returns the first `[k, v]` pair as a
           # 2-Tuple, or `Constant[nil]` when the shape is empty.

data/lib/rigor/inference/method_dispatcher.rb

@@ -12,6 +12,7 @@ require_relative "method_dispatcher/iterator_dispatch"
 require_relative "method_dispatcher/block_folding"
 require_relative "method_dispatcher/file_folding"
 require_relative "method_dispatcher/kernel_dispatch"
+require_relative "method_dispatcher/method_folding"
 
 module Rigor
   module Inference
@@ -61,11 +62,18 @@ module Rigor
       # @param environment [Rigor::Environment, nil] required for
       #   RBS-backed dispatch; when nil only constant folding can fire.
       # @return [Rigor::Type, nil] inferred result type, or `nil` for "no rule".
-      def dispatch(receiver_type:, method_name:, arg_types:, # rubocop:disable Metrics/ParameterLists
+      def dispatch(receiver_type:, method_name:, arg_types:,
                    block_type: nil, environment: nil,
                    call_node: nil, scope: nil)
         return nil if receiver_type.nil?
 
+        bound_method_result = MethodFolding.try_backward(
+          receiver: receiver_type, method_name: method_name, args: arg_types,
+          block_type: block_type, environment: environment,
+          call_node: call_node, scope: scope
+        )
+        return bound_method_result if bound_method_result
+
         precise = dispatch_precise_tiers(receiver_type, method_name, arg_types, block_type)
         return precise if precise
 
@@ -84,7 +92,37 @@ module Rigor
           receiver: receiver_type, method_name: method_name, args: arg_types,
           environment: environment, block_type: block_type
         )
-        return rbs_result if rbs_result
+        if rbs_result
+          record_boundary_cross_if_applicable(receiver_type, method_name, rbs_result, environment)
+          return rbs_result
+        end
+
+        # ADR-10 slice 2b-ii — dependency-source inference tier.
+        # Sits BELOW RBS dispatch (RBS / RBS::Inline / generated
+        # stubs / plugin contracts always win) and ABOVE the
+        # user-class fallback so a method defined in an opt-in
+        # gem stops emitting `call.undefined-method` even when
+        # no signature contract resolves. Returns
+        # `Dynamic[top]` — slice 2b-ii deliberately stops at the
+        # dynamic-origin envelope; per-method return-type
+        # precision is queued for a later slice.
+        dep_source_result = try_dependency_source(receiver_type, method_name, environment)
+        return dep_source_result if dep_source_result
+
+        # v0.1.3 — discovered-method dispatch tier. When the
+        # receiver class has no RBS BUT scope_indexer recorded
+        # `def method_name` for that class (or singleton), the
+        # call dispatches to `Dynamic[top]` rather than falling
+        # through to the user-class fallback. Sits below RBS /
+        # dependency-source so authoritative signatures still win.
+        # The scope-indexer-built table records every project-side
+        # `def`, `define_method`, and `alias_method`; the
+        # `discovered_method?` consult here closes the
+        # fail-soft-event hot spot on implicit-self calls
+        # (`sibling_private(...)`) inside `lib/rigor/`'s own
+        # internals (analyser private helpers don't have RBS).
+        discovered_result = try_discovered_method(receiver_type, method_name, scope)
+        return discovered_result if discovered_result
 
         # Slice 7 phase 10 — user-class ancestor fallback. When
         # the receiver is `Nominal[T]` or `Singleton[T]` for a
@@ -100,6 +138,58 @@ module Rigor
         try_user_class_fallback(receiver_type, method_name, arg_types, environment, block_type)
       end
 
+      # v0.1.3 — discovered-method dispatch tier. `scope` carries
+      # the `discovered_methods` table built once per program by
+      # `ScopeIndexer` (a `Hash[String, Hash[Symbol, :instance |
+      # :singleton]]`). When the receiver names a discovered
+      # class AND the requested method is recorded for that
+      # class's appropriate kind, return `Type::Combinator.untyped`
+      # — the dispatcher cannot infer a more precise return type
+      # from the bare `def` shape, but the call site stops being a
+      # fail-soft hot spot.
+      #
+      # Returns `nil` when scope / receiver class is unavailable,
+      # when the method is not in the discovered table, OR when
+      # `discovered_def_nodes` carries a re-typable body for the
+      # method (so the downstream
+      # `ExpressionTyper#try_user_method_inference` tier can
+      # re-type the body for a precise return type rather than
+      # collapsing to `Dynamic[top]` here).
+      #
+      # The tier does NOT gate on `rbs_class_known?`. RBS dispatch
+      # already had its turn upstream and returned `nil` (otherwise
+      # we wouldn't be here). When RBS knows the class but the
+      # particular method is missing from the sig — common for
+      # internal helpers and for auto-generated stubs that emit
+      # `class X` without enumerating every method — falling
+      # through to the user-class fallback would mistakenly fire
+      # `call.undefined-method`. Honoring the discovered table
+      # here keeps the sibling-private call resolution working
+      # under partial RBS coverage.
+      def try_discovered_method(receiver_type, method_name, scope)
+        return nil if scope.nil?
+
+        class_name, kind = discovered_method_lookup(receiver_type)
+        return nil if class_name.nil?
+        return nil unless scope.discovered_method?(class_name, method_name, kind)
+        return nil if kind == :instance && scope.user_def_for(class_name, method_name)
+
+        Type::Combinator.untyped
+      end
+
+      # Resolves the `(class_name, kind)` pair scope_indexer keys
+      # its `discovered_methods` table on. `Nominal[X]` looks up
+      # instance methods on X; `Singleton[X]` looks up singleton
+      # methods on X. Other carriers return `[nil, nil]` so the
+      # tier declines.
+      def discovered_method_lookup(receiver_type)
+        case receiver_type
+        when Type::Nominal then [receiver_type.class_name, :instance]
+        when Type::Singleton then [receiver_type.class_name, :singleton]
+        else [nil, nil]
+        end
+      end
+
       # ADR-2 § "Flow Contribution Bundle" / v0.1.1 Track 2
       # slice 7. Walks every loaded plugin's
       # `#flow_contribution_for(call_node:, scope:)` hook,
@@ -125,6 +215,146 @@ module Rigor
         FlowContribution::Merger.merge(contributions).return_type
       end
 
+      # ADR-10 slice 2b-ii. Consults the per-run
+      # `Analysis::DependencySourceInference::Index` carried by
+      # the environment for `(class_name, method_name)`
+      # observations harvested from opt-in gems' `roots:`. On a
+      # hit, returns `Combinator.untyped` so the call site
+      # carries the `Dynamic[top]` provenance (per ADR-10's
+      # "Inference contract": gem-source-inferred shapes never
+      # publish as ground-truth `T`). Returns `nil` when the
+      # environment carries no index, the index has no entry, or
+      # the receiver has no nominal class to look up.
+      def try_dependency_source(receiver_type, method_name, environment)
+        index = environment&.dependency_source_index
+        return nil if index.nil? || index.empty?
+
+        class_name = dep_source_class_name(receiver_type)
+        return nil if class_name.nil?
+
+        # ADR-10 5a — per-receiver plugin veto. When a
+        # registered plugin declares `manifest(owns_receivers:
+        # [<class>])` AND the call's receiver IS that class
+        # (or a subclass), decline and let plugins handle the
+        # call. Plugins that own a receiver are the
+        # authoritative source for that type; gem-source
+        # inference must not contribute behind their backs.
+        return nil if plugin_owns_receiver?(class_name, environment)
+
+        contribution_kind = index.contribution_for(class_name: class_name, method_name: method_name)
+        return Type::Combinator.untyped if contribution_kind
+
+        # ADR-10 5b — β budget semantics. On a catalog miss,
+        # if the receiver class belongs to a budget-exceeded
+        # gem AND the user opted into `:dependency_silence`,
+        # return `Dynamic[top]` rather than falling through to
+        # the user-class fallback. The user-class fallback
+        # would otherwise emit `call.undefined-method` for
+        # methods Rigor's catalog couldn't reach because the
+        # walker hit its cap.
+        budget_silence_result(class_name, index, environment)
+      end
+
+      # ADR-10 slice 5c — record a
+      # `dynamic.dependency-source.boundary-cross` event when
+      # RBS dispatch resolves a call AND the receiver class
+      # belongs to a `mode: :full` opt-in gem whose Walker
+      # also catalogued the same `(class_name, method_name)`.
+      # The dispatcher still returns the RBS answer (per
+      # ADR-10's tier order: authoritative-source wins), but
+      # the reporter accumulates the crossing for end-of-run
+      # audit diagnostics.
+      #
+      # Five honest fall-throughs keep the gate narrow:
+      #
+      # - environment / index / reporter missing — slice 5c
+      #   needs all three.
+      # - receiver has no nominal class name (Dynamic-only
+      #   carriers) — nothing to look up.
+      # - receiver class doesn't belong to a `mode: :full` gem
+      #   — the user didn't opt this gem into the distinct
+      #   dispatch path.
+      # - the gem-source catalog has no entry for the method —
+      #   only RBS knows about it; nothing to cross.
+      # - the RBS-side result is itself `Dynamic[Top]` — the
+      #   "agreement" is trivially `untyped ≈ untyped`, no
+      #   meaningful divergence to flag.
+      def record_boundary_cross_if_applicable(receiver_type, method_name, rbs_result, environment)
+        class_name = boundary_cross_class_name(receiver_type, environment, rbs_result)
+        return if class_name.nil?
+
+        index = environment.dependency_source_index
+        return unless index.full_mode?(class_name)
+        return unless index.contribution_for(class_name: class_name, method_name: method_name)
+
+        environment.boundary_cross_reporter.record(
+          class_name: class_name, method_name: method_name,
+          gem_name: index.gem_for(class_name),
+          rbs_display: rbs_display_for(rbs_result)
+        )
+      end
+
+      # Composite preflight for {#record_boundary_cross_if_applicable}.
+      # Returns the receiver class name only when every prerequisite
+      # for emitting the diagnostic is satisfied (environment carries
+      # an index + reporter, receiver is a nominal carrier, RBS-side
+      # result is not the trivial `Dynamic[Top]` envelope). Returns
+      # `nil` to short-circuit otherwise.
+      def boundary_cross_class_name(receiver_type, environment, rbs_result)
+        return nil if environment.nil?
+        return nil if environment.dependency_source_index.nil?
+        return nil if environment.dependency_source_index.empty?
+        return nil if environment.boundary_cross_reporter.nil?
+        return nil if rbs_result_untyped?(rbs_result)
+
+        dep_source_class_name(receiver_type)
+      end
+
+      def rbs_result_untyped?(rbs_result)
+        rbs_result.is_a?(Type::Dynamic) && rbs_result.static_facet.is_a?(Type::Top)
+      end
+
+      def rbs_display_for(rbs_result)
+        return "untyped" if rbs_result.nil?
+
+        rbs_result.respond_to?(:describe) ? rbs_result.describe : rbs_result.inspect
+      end
+
+      def budget_silence_result(class_name, index, _environment)
+        return nil unless index.budget_overrun_strategy == :dependency_silence
+
+        owning_gem = index.gem_for(class_name)
+        return nil if owning_gem.nil?
+        return nil unless index.budget_exceeded.include?(owning_gem)
+
+        Type::Combinator.untyped
+      end
+
+      def plugin_owns_receiver?(class_name, environment)
+        registry = environment&.plugin_registry
+        return false if registry.nil? || registry.empty?
+
+        registry.plugins.any? do |plugin|
+          owns = plugin.manifest.owns_receivers # rigor:disable undefined-method
+          owns.any? { |owner| receiver_matches_owner?(class_name, owner, environment) }
+        end
+      end
+
+      def receiver_matches_owner?(class_name, owner, environment)
+        return true if class_name == owner
+
+        ordering = environment.class_ordering(class_name, owner)
+        %i[equal subclass].include?(ordering)
+      rescue StandardError
+        false
+      end
+
+      def dep_source_class_name(receiver_type)
+        case receiver_type
+        when Type::Nominal, Type::Singleton then receiver_type.class_name
+        end
+      end
+
       def collect_plugin_contributions(registry, call_node, scope)
         registry.plugins.filter_map do |plugin|
           contribution = plugin.flow_contribution_for(call_node: call_node, scope: scope)
@@ -155,6 +385,7 @@ module Rigor
           ShapeDispatch.try_dispatch(receiver: receiver_type, method_name: method_name, args: arg_types) ||
           FileFolding.try_dispatch(receiver: receiver_type, method_name: method_name, args: arg_types) ||
           KernelDispatch.try_dispatch(receiver: receiver_type, method_name: method_name, args: arg_types) ||
+          MethodFolding.try_forward(receiver: receiver_type, method_name: method_name, args: arg_types) ||
           BlockFolding.try_fold(
             receiver: receiver_type, method_name: method_name, args: arg_types, block_type: block_type
           )

data/lib/rigor/inference/method_parameter_binder.rb

@@ -32,7 +32,6 @@ module Rigor
     # `#singleton_method`.
     #
     # See docs/internal-spec/inference-engine.md for the binding contract.
-    # rubocop:disable Metrics/ClassLength
     class MethodParameterBinder
       # @param environment [Rigor::Environment]
       # @param class_path [String, nil] the qualified name of the class
@@ -175,7 +174,7 @@ module Rigor
       # `non-empty-array[Integer]` describe the parameter binding
       # they actually want, not its element type.
       def apply_param_overrides(types, slots, rbs_method)
-        override_map = RbsExtended.param_type_override_map(rbs_method)
+        override_map = RbsExtended.param_type_override_map(rbs_method, environment: @environment)
         return if override_map.empty?
 
         slots.each do |slot|
@@ -275,6 +274,5 @@ module Rigor
         end
       end
     end
-    # rubocop:enable Metrics/ClassLength
   end
 end

data/lib/rigor/inference/narrowing.rb

@@ -376,7 +376,7 @@ module Rigor
       # the predicate shape is recognised, or `nil` to signal "no
       # narrowing" so the public surface can fall back to the entry
       # scope.
-      def analyse(node, scope) # rubocop:disable Metrics/CyclomaticComplexity
+      def analyse(node, scope)
         case node
         when Prism::ParenthesesNode
           analyse_parentheses(node, scope)
@@ -445,7 +445,6 @@ module Rigor
         # intersects each half with the integer-domain parts of
         # `current_type`. Non-integer parts of a Union receiver
         # (nil, String, …) survive unchanged.
-        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def complement_integer_range(current_type, range)
           halves = integer_range_complement_halves(range)
           parts = current_type.is_a?(Type::Union) ? current_type.members : [current_type]
@@ -466,7 +465,6 @@ module Rigor
 
           Type::Combinator.union(*survivors)
         end
-        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         # Returns the two open halves of an IntegerRange's
         # complement: the left half `int<-∞, a-1>` (when `a` is
@@ -1337,7 +1335,7 @@ module Rigor
           method_def = resolve_rbs_extended_method(node, scope)
           return nil if method_def.nil?
 
-          contribution = RbsExtended.read_flow_contribution(method_def)
+          contribution = RbsExtended.read_flow_contribution(method_def, environment: scope.environment)
           return nil if contribution.nil?
 
           result = Rigor::FlowContribution::Merger.merge([contribution])

data/lib/rigor/inference/rbs_type_translator.rb

@@ -41,7 +41,6 @@ module Rigor
     #   `Nominal[C]` regardless of which method body we are in.
     # When either argument is omitted, the corresponding token degrades
     # to Dynamic[Top].
-    # rubocop:disable Metrics/ModuleLength
     module RbsTypeTranslator
       # Hash-based dispatch keeps `translate` linear and dodges the
       # bookkeeping costs of a 20-arm `case` (RuboCop AbcSize/CCN/Length
@@ -214,6 +213,5 @@ module Rigor
         end
       end
     end
-    # rubocop:enable Metrics/ModuleLength
   end
 end

data/lib/rigor/inference/scope_indexer.rb

@@ -57,9 +57,19 @@ module Rigor
         # `Scope#with_local` / `#with_fact` / `#with_self_type`
         # propagates it across every derived scope.
         declared_types, discovered_classes = build_declaration_artifacts(root)
+        # Merge the indexer's findings on top of whatever the
+        # base scope already carries so callers that seed
+        # cross-file class knowledge (e.g. the ADR-14
+        # `SigGen::ObservationCollector` pre-walking project
+        # `lib/` before scanning `spec/`) keep their seeds
+        # alongside the per-file declarations the indexer
+        # itself discovers. Indexer-found entries win on
+        # collision — same-file declarations are the most
+        # specific authority.
+        merged_classes = default_scope.discovered_classes.merge(discovered_classes)
         seeded_scope = default_scope
                        .with_declared_types(declared_types)
-                       .with_discovered_classes(discovered_classes)
+                       .with_discovered_classes(merged_classes)
 
         # Slice 7 phase 2. Pre-pass over every class/module body
         # to collect the per-class ivar accumulator. Seeded after
@@ -300,7 +310,7 @@ module Rigor
         accumulator.freeze
       end
 
-      def walk_constant_writes(node, qualified_prefix, default_scope, accumulator) # rubocop:disable Metrics/CyclomaticComplexity
+      def walk_constant_writes(node, qualified_prefix, default_scope, accumulator)
         return unless node.is_a?(Prism::Node)
 
         case node
@@ -348,7 +358,7 @@ module Rigor
         accumulator.transform_values(&:freeze).freeze
       end
 
-      # rubocop:disable Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity, Metrics/AbcSize
+      # rubocop:disable Metrics/CyclomaticComplexity, Metrics/MethodLength
       def walk_methods(node, qualified_prefix, in_singleton_class, accumulator)
         return unless node.is_a?(Prism::Node)
 
@@ -385,7 +395,7 @@ module Rigor
           walk_methods(child, qualified_prefix, in_singleton_class, accumulator)
         end
       end
-      # rubocop:enable Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity, Metrics/AbcSize
+      # rubocop:enable Metrics/CyclomaticComplexity, Metrics/MethodLength
 
       # v0.1.2 — when a `Const = Data.define(*sym) do ... end`
       # / `Const = Struct.new(*sym) do ... end` constant write
@@ -430,7 +440,6 @@ module Rigor
         accumulator.transform_values(&:freeze).freeze
       end
 
-      # rubocop:disable Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
       def walk_def_nodes(node, qualified_prefix, in_singleton_class, accumulator)
         return unless node.is_a?(Prism::Node)
 
@@ -462,8 +471,6 @@ module Rigor
           walk_def_nodes(child, qualified_prefix, in_singleton_class, accumulator)
         end
       end
-      # rubocop:enable Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
-
       # v0.0.3 A — sentinel key under which `record_def_node`
       # files DefNodes that live outside any class / module
       # body (top-level helpers, `def`s nested inside DSL
@@ -646,7 +653,6 @@ module Rigor
 
       # Builds a map `{class_name => {new_name_sym => old_name_sym}}` by
       # walking the tree for `AliasMethodNode` nodes inside class bodies.
-      # rubocop:disable Metrics/CyclomaticComplexity
       def collect_class_alias_map(node, qualified_prefix, accumulator)
         return accumulator unless node.is_a?(Prism::Node)
 
@@ -667,7 +673,6 @@ module Rigor
         node.compact_child_nodes.each { |child| collect_class_alias_map(child, qualified_prefix, accumulator) }
         accumulator
       end
-      # rubocop:enable Metrics/CyclomaticComplexity
 
       def record_alias_map_entry(alias_node, qualified_prefix, accumulator)
         return if qualified_prefix.empty?