evilution 1.2.0 → 1.4.0

data/docs/ast_pattern_syntax.md

@@ -66,6 +66,29 @@ after calling `.to_s` on both sides:
 call{name=log}       # matches when node.name.to_s == "log"
 ```
 
+**Method names** that end in `?`, `!` or `=` are written as they are, and so are
+operator methods:
+
+```
+call{name=valid?}          # record.valid?
+call{name=strip_sources!}  # strip_sources!
+call{name=value=}          # record.value = 1
+call{name=<=>}             # a <=> b
+call{name=-@}              # -a (unary minus)
+```
+
+The bare operators are `<=>`, `===`, `==`, `=~`, `[]=`, `[]`, `<=`, `<<`, `<`,
+`>=`, `>>`, `>`, `+@`, `-@`, `+`, `-`, `/`, `%`, `&`, `^` and `~`. Any other
+name — `|`, `!`, `!=`, `!~`, `*`, `**`, a backtick — goes in single or double
+quotes, since unquoted these characters mean alternation, negation or a wildcard.
+A quoted name is matched literally:
+
+```
+call{name='|'}       # a | b, not an alternation
+call{name='*'}       # a * b, not a wildcard
+call{name='!='}      # a != b, not a negation
+```
+
 **Alternatives** use `|` (OR logic) within a single attribute value:
 
 ```
@@ -139,6 +162,13 @@ ignore_patterns:
 
   # Suppress mutations on constant `ENV` reads
   - "call{receiver=constant_read{name=ENV}}"
+
+  # Suppress mutations on bang and predicate calls, and on `<=>`
+  - "call{name=strip_sources!|eager_load!|valid?}"
+  - "call{name=<=>}"
+
+  # Quote names made of reserved characters
+  - "call{name='|'}"
 ```
 
 ## Pattern Matching Semantics
@@ -164,12 +194,21 @@ value          = "!" value
                | "*"
 nested_pattern = node_type "{" attributes "}"
 alternatives   = atom { "|" atom }
-atom           = identifier | "*"
+atom           = name | "*"
+name           = identifier [ "?" | "!" | "=" ]
+               | operator
+               | "'" { any character except "'" } "'"
+               | '"' { any character except '"' } '"'
+operator       = "<=>" | "===" | "==" | "=~" | "[]=" | "[]" | "<=" | "<<" | "<"
+               | ">=" | ">>" | ">" | "+@" | "-@" | "+" | "-" | "/" | "%"
+               | "&" | "^" | "~"
 identifier     = [a-zA-Z_] [a-zA-Z0-9_]*
 ```
 
-A bare `identifier` without `{` is parsed as a scalar value (matched via `.to_s`).
-An `identifier` followed by `{` is parsed as a nested pattern.
+A bare `name` without `{` is parsed as a scalar value (matched via `.to_s`).
+An `identifier` followed by `{` is parsed as a nested pattern. Operators are
+read longest first, so `<=>` is never taken for `<=`. Node types and attribute
+names are always plain identifiers. A quoted name is at least one character long.
 
 ## Examples
 
@@ -183,6 +222,9 @@ An `identifier` followed by `{` is parsed as a nested pattern.
 | `call{receiver=**}` | `foo()`, `x.foo()`, `a.b.foo()` | *(matches all)* |
 | `def{name=to_s}` | `def to_s; ... end` | `def to_str; ... end` |
 | `call{name=!log}` | `debug()`, `info()` | `log()` |
+| `call{name=valid?\|save!}` | `x.valid?`, `save!` | `valid`, `save` |
+| `call{name=<=>}` | `a <=> b` | `a <= b` |
+| `call{name='\|'}` | `a \| b` | `a & b` |
 
 ## Design Decisions
 
@@ -191,8 +233,11 @@ An `identifier` followed by `{` is parsed as a nested pattern.
    write patterns immediately.
 
 2. **Unquoted values**: Attribute values don't require quotes. This keeps YAML clean
-   and avoids escaping issues. The tradeoff is that values cannot contain `{`, `}`,
-   `,`, `=`, `|`, or `!` — these are reserved syntax characters.
+   and avoids escaping issues. Method names ending in `?`, `!` or `=` and operators
+   that cannot be confused with pattern syntax are written bare too. Only names
+   built from reserved characters (`|`, `!`, `*`) or characters outside a method
+   name need quotes; there is no escaping inside them. In YAML, use one kind of
+   quote for the YAML string and the other inside it: `- "call{name='|'}"`.
 
 3. **Implicit wildcards for unspecified attributes**: `call{name=log}` matches
    regardless of receiver, arguments, etc. Only specified attributes constrain the

data/docs/isolation.md

@@ -22,8 +22,8 @@ transaction block with a half-delivered exception. The mask is
 [load-bearing for transaction correctness][rails-handle-interrupt].
 
 That mask interacts badly with `Timeout.timeout`. The Timeout gem schedules a
-timer thread which fires `Thread#raise Timeout::Error` at the main thread when
-the deadline hits. Ruby receives the `raise`, inspects the interrupt mask, sees
+timer thread which fires `Thread#raise` at the main thread when the deadline
+hits. Ruby receives the `raise`, inspects the interrupt mask, sees
 `Exception => :never`, and **queues the exception for later delivery** — "later"
 meaning "when the masked block exits". If the mutant is stuck in an infinite
 loop inside the transaction, the block never exits, the queued exception is
@@ -57,6 +57,26 @@ The same hazard applies to any Ruby code that uses
 blocks that wrap "must complete" sections. If your target code can touch any
 of those, prefer `--isolation fork`.
 
+## How `in_process` ends a run that is out of time
+
+The timeout raises `Evilution::Isolation::InProcess::Expired` into the run. It
+is a `SignalException`, not a `Timeout::Error`, because it has to end the
+whole test run. A test framework rescues nearly everything a test raises:
+handed a `Timeout::Error`, it records one failed test and moves on to the
+next, which may reach the same endless loop with no timer left to stop it.
+Minitest, Test::Unit and RSpec all let a `SignalException` through, so the run
+stops at once and the mutation is reported as timed out rather than killed.
+
+It is not an `Interrupt` either. Tooling that handles Ctrl-C — maxitest, for
+one — rescues `Interrupt` and skips every test from then on, which would turn
+each later mutation in the process into a survivor.
+
+One raise is all there is. Code under test, or a test, that rescues
+`Exception` or `SignalException` and then loops again cannot be stopped from
+inside its own process; use `--isolation fork` for it. The same goes for a
+mutant that crashes the Ruby VM: under `fork` that costs one child, under
+`in_process` the whole run.
+
 ## Parent-process preload
 
 Fork isolation's one downside is that every child pays the cost of loading
@@ -132,6 +152,23 @@ the MCP server is a long-lived process that handles runs from different
 projects — preloading one project's Rails stack into a shared process would
 poison subsequent runs.
 
+## Test files under `in_process` (Minitest, Test::Unit)
+
+Under `in_process` one process runs every mutation, and Minitest and
+Test::Unit learn of a test class only when it is first defined: loading its
+file a second time reopens the class and registers nothing. Each test file is
+therefore loaded once per process, and the classes it registered are
+dispatched again for every later mutation
+(`Integration::Loading::TestClassCache`).
+
+The consequence is that code in the body of a test file runs once. Tests
+generated at load time from the code under test (`OPS.each { |op|
+define_method("test_#{op}") { … } }`) keep the set built on the first load,
+and state held on a test class carries over from one mutation to the next.
+Under `fork` every child loads the file itself, so use `--isolation fork` for
+a suite that depends on either. RSpec is unaffected: it is reset and its spec
+files are loaded again for each mutation.
+
 ## Sandboxed working directory
 
 Every isolator runs `test_command.call` inside a per-mutation scratch

data/docs/migration-from-mutant.md

@@ -142,7 +142,7 @@ Key-by-key:
 | `matcher.ignore` | `ignore_patterns` / `# evilution:disable` | AST patterns or inline comments |
 | `fail_fast` | `fail_fast` | integer N or `null` |
 | `--score` gate (CLI; default `1.0`) | `min_score` | evilution defaults to `0.0` — set your own gate |
-| _(n/a)_ | `profile: strict` | opt into aggressive truthiness mutators |
+| _(n/a)_ | `profile: strict` | opt into aggressive mutators (truthiness, swallowed errors, statement order) |
 
 Run `evilution init` for a fully commented template, and point your editor at
 `schema/evilution.config.schema.json` for autocomplete/validation.

data/lib/evilution/ast/aasm_declaration.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+require "prism"
+require_relative "../ast"
+require_relative "literal_callable"
+
+# The guards and callbacks of an AASM state machine that are written out as
+# literal callables:
+#
+#   aasm do
+#     state :paid, before_exit: -> { ... }
+#     event :ship, guard: -> { ... } do
+#       before { ... }
+#       transitions from: :paid, to: :shipped, guard: -> { ... }
+#     end
+#   end
+#
+# Each belongs to the `event` or `state` declaration it is written in. AASM
+# keeps what a declaration holds by value, so running that one declaration
+# again replaces it, and a mutated body takes effect. The machine's own
+# callbacks (`after_all_transitions`) accumulate instead, and are left out.
+#
+# Only a receiver-less `aasm` call with a block, written directly in a class
+# body, counts: that is the call the mutated file re-runs.
+module Evilution::AST::AasmDeclaration
+  # body: the node holding the callable's body. declaration: its `event` or
+  # `state` call. method_name: the instance method that declaration defines.
+  Callable = Data.define(:body, :declaration, :method_name)
+
+  DECLARATIONS = %i[event state].freeze
+  EVENT_CALLBACKS = %i[
+    before before_transaction before_success success after after_transaction after_commit error ensure
+  ].freeze
+  private_constant :DECLARATIONS, :EVENT_CALLBACKS
+
+  # The callables of every machine among a class body's direct statements.
+  def self.in_body(body)
+    statements_of(body).flat_map { |node| machine_callables(node) }
+  end
+
+  # The block of an `aasm` call, or nil when node is not one.
+  def self.machine_block(node)
+    return nil unless node.is_a?(Prism::CallNode) && node.name == :aasm && node.receiver.nil?
+
+    node.block if node.block.is_a?(Prism::BlockNode)
+  end
+
+  # The name specs call for whatever sits on a line of a machine: the event,
+  # or the first state, declared there. nil outside every declaration.
+  def self.token_at(machine, line)
+    declaration = declarations_of(machine).find do |node|
+      line.between?(node.location.start_line, node.location.end_line)
+    end
+    declaration && declared_name(declaration)
+  end
+
+  def self.machine_callables(machine)
+    declarations_of(machine).flat_map do |declaration|
+      bodies_of(declaration).map do |body|
+        Callable.new(body: body, declaration: declaration, method_name: method_name(declaration))
+      end
+    end
+  end
+
+  def self.declarations_of(machine)
+    block = machine_block(machine)
+    return [] unless block
+
+    statements_of(block.body).select { |node| declaration?(node) }
+  end
+
+  def self.declaration?(node)
+    bare_call?(node) && DECLARATIONS.include?(node.name) && arguments_of(node).first.is_a?(Prism::SymbolNode)
+  end
+
+  def self.declared_name(declaration)
+    arguments_of(declaration).first.unescaped
+  end
+
+  # `event :ship` defines `ship`; `state :paid` defines `paid?`.
+  def self.method_name(declaration)
+    declaration.name == :event ? declared_name(declaration) : "#{declared_name(declaration)}?"
+  end
+
+  def self.bodies_of(declaration)
+    keyword_bodies(declaration) + (declaration.name == :event ? event_block_bodies(declaration) : [])
+  end
+
+  # What an event's block holds: its transitions, with keyword callables of
+  # their own, and callbacks given as blocks (`before { }`).
+  def self.event_block_bodies(event)
+    return [] unless event.block.is_a?(Prism::BlockNode)
+
+    statements_of(event.block.body).select { |node| bare_call?(node) }.flat_map do |node|
+      if node.name == :transitions then keyword_bodies(node)
+      elsif callback_block?(node) then [node.block]
+      else []
+      end
+    end
+  end
+
+  def self.callback_block?(node)
+    EVENT_CALLBACKS.include?(node.name) && node.arguments.nil? && node.block.is_a?(Prism::BlockNode)
+  end
+
+  # `guard: -> { }` and `guards: [-> { }, :named]` alike.
+  def self.keyword_bodies(call)
+    keywords = arguments_of(call).last
+    return [] unless keywords.is_a?(Prism::KeywordHashNode)
+
+    keywords.elements.grep(Prism::AssocNode).flat_map do |pair|
+      values = pair.value.is_a?(Prism::ArrayNode) ? pair.value.elements : [pair.value]
+      values.filter_map { |value| Evilution::AST::LiteralCallable.body_of(value) }
+    end
+  end
+
+  def self.bare_call?(node)
+    node.is_a?(Prism::CallNode) && node.receiver.nil?
+  end
+
+  def self.arguments_of(call)
+    call.arguments ? call.arguments.arguments : []
+  end
+
+  def self.statements_of(body)
+    body = body.statements if body.is_a?(Prism::BeginNode)
+    body.is_a?(Prism::StatementsNode) ? body.body : []
+  end
+
+  private_class_method :machine_callables, :declarations_of, :declaration?, :declared_name, :method_name,
+                       :bodies_of, :event_block_bodies, :callback_block?, :keyword_bodies, :bare_call?,
+                       :arguments_of, :statements_of
+end

data/lib/evilution/ast/callback_declaration.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require "prism"
+require_relative "../ast"
+require_relative "literal_callable"
+
+# The callables written out in a callback or validation declaration of a
+# class body:
+#
+#   validate :credit_limit, if: -> { paid? && total.positive? }
+#   validates :title, presence: true, unless: [-> { draft? }, :imported?]
+#   before_save { self.slug = title.parameterize }
+#   after_commit -> { notify }, on: :create
+#
+# That is the condition given to `if:` / `unless:`, and the callback itself
+# when it is a block or a lambda. A condition or callback named by a symbol
+# is a method, and a subject of its own already.
+#
+# Declarations are recognised by name -- `validate`, `validates`,
+# `validates_*`, `before_*`, `after_*`, `around_*` -- and only receiver-less,
+# directly in a class body: that is the call the mutated file re-runs.
+module Evilution::AST::CallbackDeclaration
+  # body: the node holding the callable's body. declaration: the call it is
+  # written in. label: how the declaration reads, for naming the subject.
+  Callable = Data.define(:body, :declaration, :label)
+
+  NAME = /\A(?:validate|validates|validates_\w+|(?:before|after|around)_\w+)\z/
+  CONDITIONS = %w[if unless].freeze
+  private_constant :NAME, :CONDITIONS
+
+  # The callables of every callback declaration among a class body's direct
+  # statements.
+  def self.in_body(body)
+    statements = body.is_a?(Prism::BeginNode) ? body.statements : body
+    return [] unless statements.is_a?(Prism::StatementsNode)
+
+    statements.body.select { |node| match?(node) }.flat_map { |declaration| callables(declaration) }
+  end
+
+  # Whether node is a callback declaration that can be run again on its own.
+  # One holding a heredoc cannot be wrapped on its own lines, and is left out.
+  def self.match?(node)
+    node.is_a?(Prism::CallNode) && node.receiver.nil? && NAME.match?(node.name.to_s) && !heredoc?(node)
+  end
+
+  def self.callables(declaration)
+    label = label_of(declaration)
+    bodies_of(declaration).map { |body| Callable.new(body: body, declaration: declaration, label: label) }
+  end
+
+  # `validate :credit_limit, if: ...` reads as `validate(:credit_limit)`; a
+  # declaration naming nothing, as its own name.
+  def self.label_of(declaration)
+    named = arguments_of(declaration).find { |argument| argument.is_a?(Prism::SymbolNode) }
+    named ? "#{declaration.name}(:#{named.unescaped})" : declaration.name.to_s
+  end
+
+  def self.bodies_of(declaration)
+    arguments = arguments_of(declaration)
+    bodies = arguments.filter_map { |argument| Evilution::AST::LiteralCallable.body_of(argument) }
+    bodies.concat(condition_bodies(arguments.last))
+    bodies << declaration.block if declaration.block.is_a?(Prism::BlockNode)
+    bodies
+  end
+
+  # `if: -> { }` and `unless: [-> { }, :named]` alike.
+  def self.condition_bodies(keywords)
+    return [] unless keywords.is_a?(Prism::KeywordHashNode)
+
+    keywords.elements.select { |pair| condition?(pair) }.flat_map do |pair|
+      values = pair.value.is_a?(Prism::ArrayNode) ? pair.value.elements : [pair.value]
+      values.filter_map { |value| Evilution::AST::LiteralCallable.body_of(value) }
+    end
+  end
+
+  def self.condition?(pair)
+    pair.is_a?(Prism::AssocNode) && pair.key.is_a?(Prism::SymbolNode) && CONDITIONS.include?(pair.key.unescaped)
+  end
+
+  def self.arguments_of(call)
+    call.arguments ? call.arguments.arguments : []
+  end
+
+  def self.heredoc?(node)
+    return true if node.respond_to?(:heredoc?) && node.heredoc?
+
+    node.compact_child_nodes.any? { |child| heredoc?(child) }
+  end
+
+  private_class_method :callables, :label_of, :bodies_of, :condition_bodies, :condition?, :arguments_of, :heredoc?
+end

data/lib/evilution/ast/included_block.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "prism"
+require_relative "../ast"
+
+# The block of an `ActiveSupport::Concern`'s `included do ... end`: code
+# written in a module body that runs in the body of each class including the
+# module. Only the receiver-less, argument-less form with a literal block
+# counts -- `def self.included(base)` and `included(base) { }` are plain Ruby
+# hooks with rules of their own.
+module Evilution::AST::IncludedBlock
+  # The block node, or nil when node is not an `included` block call.
+  def self.of(node)
+    return nil unless node.is_a?(Prism::CallNode) && node.name == :included
+    return nil unless node.receiver.nil? && node.arguments.nil?
+
+    node.block if node.block.is_a?(Prism::BlockNode)
+  end
+
+  # The included blocks among a module body's direct statements.
+  def self.in_body(body)
+    statements = body.is_a?(Prism::BeginNode) ? body.statements : body
+    return [] unless statements.is_a?(Prism::StatementsNode)
+
+    statements.body.filter_map { |node| of(node) }
+  end
+end

data/lib/evilution/ast/literal_callable.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "prism"
+require_relative "../ast"
+
+# A callable written out where it is used: `-> { }`, `lambda { }` or
+# `proc { }`. Its body is what mutations go into. A constant, a variable or
+# `method(:name)` in the same place has no body of its own to mutate.
+module Evilution::AST::LiteralCallable
+  BLOCK_CALLS = %i[lambda proc].freeze
+  private_constant :BLOCK_CALLS
+
+  # The node holding the callable's body -- a LambdaNode, or the BlockNode of
+  # a `lambda` / `proc` call -- or nil when node is not a literal callable.
+  def self.body_of(node)
+    return node if node.is_a?(Prism::LambdaNode)
+    return nil unless node.is_a?(Prism::CallNode) && node.receiver.nil? && BLOCK_CALLS.include?(node.name)
+
+    node.block if node.block.is_a?(Prism::BlockNode)
+  end
+end

data/lib/evilution/ast/parser.rb

@@ -1,6 +1,12 @@
 # frozen_string_literal: true
 
 require "prism"
+require_relative "../ast"
+require_relative "value_object_definition"
+require_relative "scope_declaration"
+require_relative "aasm_declaration"
+require_relative "included_block"
+require_relative "callback_declaration"
 
 module Evilution::AST
   class Parser
@@ -39,55 +45,153 @@ module Evilution::AST
       @file_path = file_path
       @subjects = []
       @context = []
+      @singleton = [false]
     end
 
     def visit_module_node(node)
       @context.push(constant_name(node.constant_path))
-      super
+      IncludedBlock.in_body(node.body).each do |block|
+        add_scope_subjects(block.body)
+        add_aasm_subjects(block.body)
+        add_callback_subjects(block.body)
+      end
+      within_scope(singleton: false) { super }
       @context.pop
     end
 
+    # A class whose superclass is a value-object definition
+    # (`class Coord < Data.define(:lat, :lng)`) makes a constant subject of
+    # that definition, named after the class.
     def visit_class_node(node)
       @context.push(constant_name(node.constant_path))
-      super
+      superclass = node.superclass
+      add_subject(superclass, @context.join("::"), :constant) if ValueObjectDefinition.match?(superclass)
+      add_scope_subjects(node.body)
+      add_aasm_subjects(node.body)
+      add_callback_subjects(node.body)
+      within_scope(singleton: false) { super }
       @context.pop
     end
 
+    # A `def` inside `class << self` defines a method on the enclosing
+    # class's singleton, like `def self.name`; inside `class << Store` it
+    # defines one on Store.
+    def visit_singleton_class_node(node)
+      constant = constant_expression?(node.expression)
+      @context.push(constant_name(node.expression)) if constant
+      within_scope(singleton: true) { super }
+      @context.pop if constant
+    end
+
     def visit_def_node(node)
-      separator = node.receiver ? "." : "#"
-      add_subject(node, separator)
+      separator = node.receiver || @singleton.last ? "." : "#"
+      add_subject(node, "#{@context.join("::")}#{separator}#{node.name}", :method)
       super
     end
 
+    def visit_constant_write_node(node)
+      return super unless ValueObjectDefinition.match?(node.value)
+
+      within_definition(node.value, node.name.to_s) { super }
+    end
+
+    def visit_constant_path_write_node(node)
+      return super unless ValueObjectDefinition.match?(node.value)
+
+      within_definition(node.value, path_name(node.target)) { super }
+    end
+
     private
 
-    def add_subject(node, separator)
-      scope = @context.join("::")
-      name = if scope.empty?
-               "#{separator}#{node.name}"
-             else
-               "#{scope}#{separator}#{node.name}"
-             end
+    def within_scope(singleton:)
+      @singleton.push(singleton)
+      yield
+    ensure
+      @singleton.pop
+    end
+
+    def constant_expression?(node)
+      node.is_a?(Prism::ConstantReadNode) || node.is_a?(Prism::ConstantPathNode)
+    end
+
+    # A value-object definition assigned to a constant is a subject of its
+    # own, and a scope for what its block defines: `def area` in
+    # `Size = Struct.new(:w, :h) do ... end` is `Size#area`.
+    def within_definition(definition, name)
+      @context.push(name)
+      add_subject(definition, @context.join("::"), :constant)
+      yield
+      @context.pop
+    end
+
+    # `scope :recent, -> { ... }` defines the class method `recent`. The
+    # subject spans the whole declaration and mutates its body.
+    # Written in a concern's `included` block it defines that method on every
+    # class including the concern, and is named after the concern.
+    def add_scope_subjects(body)
+      ScopeDeclaration.in_body(body).each do |declaration|
+        name = "#{@context.join("::")}.#{ScopeDeclaration.scope_name(declaration)}"
+        add_subject(ScopeDeclaration.body_of(declaration), name, :scope, span: declaration)
+      end
+    end
+
+    # A guard or callback written out inside `aasm do ... end` runs when the
+    # method its event or state defines is called (`ship`, `paid?`), and is
+    # named after it. The subject spans that declaration and mutates the
+    # callable's body; one event may hold several. A machine declared in a
+    # concern's `included` block is named after the concern.
+    def add_aasm_subjects(body)
+      AasmDeclaration.in_body(body).each do |callable|
+        name = "#{@context.join("::")}##{callable.method_name}"
+        add_subject(callable.body, name, :aasm, span: callable.declaration)
+      end
+    end
 
-      loc = node.location
-      method_source = @source.byteslice(loc.start_offset, loc.end_offset - loc.start_offset)
-                             .force_encoding(@source.encoding)
+    # A condition or a callback written out in a declaration such as
+    # `validate :credit_limit, if: -> { ... }` defines no method to be named
+    # after, so it is named the way the declaration reads:
+    # `Order.validate(:credit_limit)`. The subject spans the declaration and
+    # mutates the callable's body. In a concern's `included` block it is named
+    # after the concern.
+    def add_callback_subjects(body)
+      CallbackDeclaration.in_body(body).each do |callable|
+        add_subject(callable.body, "#{@context.join("::")}.#{callable.label}", :callback, span: callable.declaration)
+      end
+    end
+
+    def add_subject(node, name, kind, span: node)
+      loc = span.location
+      source = @source.byteslice(loc.start_offset, loc.end_offset - loc.start_offset)
+                      .force_encoding(@source.encoding)
 
       @subjects << Evilution::Subject.new(
         name: name,
         file_path: @file_path,
         line_number: loc.start_line,
-        source: method_source,
-        node: node
+        source: source,
+        node: node,
+        kind: kind
       )
     end
 
+    # `self::Unit` has no static full name; it is named within the scope it
+    # is written in, like a plain `Unit`.
+    def path_name(target)
+      target.full_name.delete_prefix("::")
+    rescue Prism::ConstantPathNode::DynamicPartsInConstantPathError
+      target.name.to_s
+    end
+
+    # `class self::Unit` and `class << self::Unit` have no static full name
+    # either; like `path_name`, they are named by their own constant.
     def constant_name(node)
       if node.respond_to?(:full_name)
         node.full_name
       else
         node.name.to_s
       end
+    rescue Prism::ConstantPathNode::DynamicPartsInConstantPathError
+      node.name.to_s
     end
   end
 end

data/lib/evilution/ast/pattern/filter.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require_relative "../pattern"
 require_relative "parser"
 
 class Evilution::AST::Pattern::Filter