henitai 0.5.1 → 0.6.0

data/lib/henitai/mutant_generator.rb

@@ -6,7 +6,7 @@ require_relative "source_parser"
 module Henitai
   # Traverses a subject's AST and asks operators to build mutants.
   class MutantGenerator
-    def generate(subjects, operators, config: nil)
+    def generate(subjects, operators, config: nil, sample: true)
       normalized_operators = normalize_operators(operators)
       arid_node_filter = AridNodeFilter.new
       syntax_validator = SyntaxValidator.new
@@ -22,7 +22,12 @@ module Henitai
         )
       end
 
-      sample_mutants(mutants, config:, sampling_strategy:)
+      # Deduplicate programs before sampling: unsampled generation (survivor reruns) must keep the same
+      # representative of a duplicate program as a sampled run, or a reported survivor's stable id would
+      # not be found again. Sampling is stratified by operator within each subject, using a seeded
+      # per-mutant order, and returns kept mutants in input order.
+      unique = distinct_programs(distinct_identities(mutants))
+      sample ? sample_mutants(unique, config:, sampling_strategy:) : unique
     end
 
     private
@@ -71,14 +76,12 @@ module Henitai
       def walk(node, parent: nil)
         return unless node.is_a?(Parser::AST::Node)
 
-        # Str children of a non-heredoc dstr are raw text segments embedded
-        # inside a quoted interpolated string. They have no surrounding quotes
-        # in the source, so replacing them via source-fragment substitution
-        # would insert a quoted literal into the raw-text position and produce
-        # a SyntaxError when the mutant is activated.
-        # Heredoc dstr children are exempt: the heredoc body is plain text, so
-        # inserting "" there stays valid Ruby.
-        return if embedded_non_heredoc_dstr_str?(node, parent)
+        # A str node inside an interpolated string, heredoc, symbol, command,
+        # regexp or word array is raw text without quotes of its own.
+        # Replacing it would insert a quoted literal into the text -- a
+        # different mutation than reported, or a SyntaxError -- so it is not
+        # a StringLiteral site; its container is mutated instead.
+        return if raw_text_segment?(node, parent) || shorthand_value?(node, parent)
 
         apply_operators(node) if node_within_subject_range?(node)
         node.children.each do |child|
@@ -86,18 +89,29 @@ module Henitai
         end
       end
 
-      def embedded_non_heredoc_dstr_str?(node, parent)
-        node.type == :str &&
-          parent&.type == :dstr &&
-          !heredoc_node?(parent)
+      RAW_TEXT_CONTAINERS = %i[dstr dsym xstr regexp].freeze
+      private_constant :RAW_TEXT_CONTAINERS
+
+      def raw_text_segment?(node, parent)
+        return false unless node.type == :str && parent
+
+        RAW_TEXT_CONTAINERS.include?(parent.type) || word_array?(parent)
       end
 
-      def heredoc_node?(node)
-        node.location.respond_to?(:heredoc_body) && node.location.heredoc_body
+      # The value of +build(config:)+ is an implicit call that shares its
+      # source range with the key; replacing it would rewrite the key.
+      def shorthand_value?(node, parent)
+        return false unless parent&.type == :pair && node.equal?(parent.children[1])
+
+        node.location.expression == parent.children[0].location.expression
+      end
+
+      def word_array?(node)
+        node.type == :array && node.location.begin&.source.to_s.start_with?("%")
       end
 
       def apply_operators(node)
-        return if @arid_node_filter.suppressed?(node, @config)
+        return if @arid_node_filter.suppressed?(node)
 
         @operators_by_node_type[node.type].each do |operator|
           operator.mutate(node, subject: @subject).each do |mutant|
@@ -132,6 +146,35 @@ module Henitai
       end
     end
 
+    # Mutants sharing an identity are told apart by where their original node
+    # ends; those that also end at the same place are the same mutation
+    # twice, and only the first is kept.
+    def distinct_identities(mutants)
+      mutants.group_by { |mutant| MutantIdentity.stable_id(mutant) }.each_value do |group|
+        group.each { |mutant| mutant.identity_discriminator = node_end(mutant) } if group.size > 1
+      end
+      mutants.uniq { |mutant| MutantIdentity.stable_id(mutant) }
+    end
+
+    # Different operators can produce the same program -- BooleanLiteral's
+    # `return false` for `return true if x` is also ReturnValue's. Running it
+    # twice would count one result twice; the first mutant is kept. Mutants
+    # without a computable activation are left to the later checks.
+    def distinct_programs(mutants)
+      seen = {}
+      mutants.select do |mutant|
+        program = Mutant::Activator.activation_source_for(mutant)
+        key = [mutant.subject, program]
+        program.nil? || (!seen.key?(key) && (seen[key] = true))
+      end
+    end
+
+    def node_end(mutant)
+      range = mutant.original_node&.location&.expression
+      start = mutant.subject.source_range&.begin
+      range && start ? "#{range.last_line - start}:#{range.last_column}" : range&.end_pos.to_s
+    end
+
     def sample_mutants(mutants, config:, sampling_strategy:)
       sampling = config&.sampling
       return mutants unless sampling
@@ -140,7 +183,8 @@ module Henitai
       sampling_strategy.sample(
         mutants,
         ratio: sampling[:ratio],
-        strategy: sampling[:strategy] || :stratified
+        strategy: sampling[:strategy] || :stratified,
+        seed: sampling[:seed] || SamplingStrategy::DEFAULT_SEED
       )
     end
 

data/lib/henitai/mutant_history_store/verdict_cache.rb

@@ -29,7 +29,7 @@ module Henitai
       def killed_cache_bindings(mutant)
         [
           VerdictFingerprint.subject_source_hash(mutant),
-          VerdictFingerprint.tests_fingerprint(covered_tests_for(mutant))
+          VerdictFingerprint.tests_fingerprint(covered_tests_for(mutant), context_sha: reuse_context&.fingerprint)
         ]
       end
 
@@ -38,34 +38,35 @@ module Henitai
       # which reflects selector fallback and test_excludes and would
       # permanently mismatch the live set. When the fingerprint cannot be
       # recomputed (no per-test map, recipe stubs without a source range),
-      # the previously stored bindings are kept: the filter re-validates
-      # everything live before reuse, so a carried-forward fingerprint can
-      # never validate a changed state.
+      # the previously stored bindings are kept, but only from a survived
+      # row of the same subject source: a killed row's or an edited method's
+      # fingerprints would vouch for a state this survivor never ran in.
       def survived_cache_bindings(mutant, existing_row)
         bindings = [
           VerdictFingerprint.subject_source_hash(mutant),
           survived_tests_fingerprint(mutant)
         ]
         return bindings unless bindings.any?(&:nil?)
+        return [nil, nil] unless carry_survived_bindings?(bindings.first, existing_row)
 
         existing_cache_bindings(existing_row)
       end
 
+      def carry_survived_bindings?(source_hash, existing_row)
+        return false unless existing_row && existing_row["current_status"] == "survived"
+
+        source_hash.nil? || source_hash == existing_row["subject_source_hash"]
+      end
+
       def survived_tests_fingerprint(mutant)
         return nil unless per_test_coverage
 
         VerdictFingerprint.survivor_tests_fingerprint(
           per_test_coverage.tests_covering(mutant),
-          dependency_sha: recording_dependency_sha
+          context_sha: reuse_context&.fingerprint
         )
       end
 
-      # One dependency sha per record call set, computed lazily so runs
-      # without survivors never touch the dependency files.
-      def recording_dependency_sha
-        @recording_dependency_sha ||= VerdictFingerprint.dependency_fingerprint
-      end
-
       def existing_cache_bindings(existing_row)
         return [nil, nil] unless existing_row
 

data/lib/henitai/mutant_history_store.rb

@@ -17,9 +17,12 @@ module Henitai
     # @param per_test_coverage [PerTestCoverage, nil] live per-test coverage
     #   view used to record the full-map intersection set for survived
     #   verdicts; without it survived rows stay NULL (never reusable).
-    def initialize(path:, per_test_coverage: nil)
+    # @param reuse_context [ReuseContext, nil] fingerprint recorded with every
+    #   cached verdict; without it no verdict is cached (never reusable).
+    def initialize(path:, per_test_coverage: nil, reuse_context: nil)
       @path = path
       @per_test_coverage = per_test_coverage
+      @reuse_context = reuse_context
     end
 
     attr_reader :path
@@ -30,7 +33,7 @@ module Henitai
       with_database do |db|
         ensure_schema(db)
         db.transaction do
-          insert_run(db, result, version, recorded_at) unless partial_rerun?(result)
+          insert_run(db, result, version, recorded_at) if full_run?(result)
           Array(result.mutants).each do |mutant|
             upsert_mutant(db, mutant, version, recorded_at)
           end
@@ -72,7 +75,7 @@ module Henitai
 
     private
 
-    attr_reader :per_test_coverage
+    attr_reader :per_test_coverage, :reuse_context
 
     def verdict_from_row(row)
       return nil unless row && VerdictCache::CACHEABLE_STATUSES.include?(row["current_status"])
@@ -85,6 +88,11 @@ module Henitai
       }
     end
 
+    def full_run?(result)
+      authoritative = !result.respond_to?(:authoritative?) || result.authoritative?
+      authoritative && !partial_rerun?(result)
+    end
+
     def partial_rerun?(result)
       result.respond_to?(:partial_rerun?) && result.partial_rerun?
     end
@@ -133,8 +141,10 @@ module Henitai
       end
     end
 
+    # Recipe stubs carry a precomputed id that cannot be recomputed from
+    # their (absent) AST nodes.
     def stable_mutant_id(mutant)
-      MutantIdentity.stable_id(mutant)
+      mutant.respond_to?(:stable_id) ? mutant.stable_id : MutantIdentity.stable_id(mutant)
     end
 
     def mutation_history_entry(mutant, version, recorded_at)

data/lib/henitai/mutant_identity.rb

@@ -19,8 +19,12 @@ module Henitai
       digest(legacy_identity_components(mutant))
     end
 
+    # The discriminator is present only for mutants that would otherwise
+    # share an identity -- nested nodes starting at the same position, such
+    # as the calls of `x.a.b.c` -- so every other identity stays unchanged.
     def self.identity_components(mutant)
-      legacy_identity_components(mutant) + [site_offset(mutant)]
+      discriminator = mutant.respond_to?(:identity_discriminator) && mutant.identity_discriminator
+      legacy_identity_components(mutant) + [site_offset(mutant)] + [discriminator].compact
     end
     private_class_method :identity_components
 

data/lib/henitai/mutant_verdict.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Henitai
+  # Classifies one mutant run from the child's own report and the way the
+  # child process ended.
+  #
+  # The child reports what it got to: a failed activation, a finished test run
+  # with the exit code the tests returned, or a SystemExit raised while the
+  # tests ran. Only a finished test run yields a test verdict (Killed or
+  # Survived); everything else is a harness or runtime status that stays out of
+  # the detected count. In particular a child that died without a report, or
+  # was killed by a signal, is a RuntimeError, never a kill.
+  class MutantVerdict
+    def initialize(wait_result:, report:, stdout:, stderr:)
+      @wait_result = wait_result
+      @report = report
+      @output = "#{stdout}\n#{stderr}"
+    end
+
+    # @return [Array(Symbol, String|nil)] status and reason
+    def to_a
+      return [:timeout, nil] if @wait_result == :timeout
+      return [:runtime_error, "child terminated by signal #{signal_name}"] if signaled?
+      return [:runtime_error, "child exited with status #{exit_status} without reporting a result"] unless @report
+
+      reported_verdict
+    end
+
+    # @return [Array<String>] expanded paths of the test files that failed
+    #   in the child, or an empty list when the child did not report them or
+    #   also saw a failure it could not attribute to a file (which makes the
+    #   kill genuine, never one a flaky file alone may have caused)
+    def killing_tests
+      return [] if @report.nil? || @report["unattributed_failures"]
+
+      Array(@report["failed_tests"]).map { |path| File.expand_path(path) }
+    end
+
+    private
+
+    def reported_verdict
+      case @report["outcome"]
+      when "activation_failed" then [:compile_error, "activation failed: #{@report['reason']}"]
+      when "environment_failed"
+        [:compile_error, "the test files failed to load, before the mutant was activated"]
+      when "system_exit"
+        [:runtime_error, "the test run ended early with SystemExit (status #{@report['status']})"]
+      when "tests_finished" then test_verdict
+      else [:runtime_error, "child reported an unknown outcome: #{@report['outcome']}"]
+      end
+    end
+
+    def test_verdict
+      return [:compile_error, "no examples ran"] if ExampleSummary.none_ran?(@output)
+
+      @report["exit_code"].to_i.zero? ? [:survived, nil] : [:killed, nil]
+    end
+
+    def signaled?
+      @wait_result.respond_to?(:signaled?) && @wait_result.signaled?
+    end
+
+    def signal_name
+      "SIG#{Signal.signame(@wait_result.termsig)}"
+    end
+
+    def exit_status
+      @wait_result.respond_to?(:exitstatus) ? @wait_result.exitstatus : "unknown"
+    end
+  end
+end

data/lib/henitai/operators/array_declaration.rb

@@ -12,7 +12,11 @@ module Henitai
         NODE_TYPES
       end
 
+      # A list without brackets (rescue classes, multiple return values,
+      # multiple assignment) is not an array literal and has no empty form.
       def mutate(node, subject:)
+        return [] unless node.location.begin
+
         if node.children.empty?
           [empty_array_mutant(subject:, node:)]
         else

data/lib/henitai/operators/assignment_expression.rb

@@ -51,6 +51,8 @@ module Henitai
         when :casgn
           namespace, name = left.children
           Parser::AST::Node.new(:casgn, [namespace, name, right])
+        when :indexasgn
+          left.updated(nil, [*left.children, right])
         when :send
           assignment_name = left.children[1] == :[] ? :[]= : :"#{left.children[1]}="
           receiver, _method_name, *arguments = left.children

data/lib/henitai/operators/conditional_expression.rb

@@ -28,6 +28,8 @@ module Henitai
       private
 
       def mutate_if(node, subject:)
+        return elsif_condition_mutants(node, subject:) if elsif?(node)
+
         condition, then_branch, else_branch = node.children
         mutations = condition_variants(node, subject:, condition:)
 
@@ -38,6 +40,22 @@ module Henitai
         mutations
       end
 
+      # An elsif's source range starts at `elsif` and has no `end`, so a
+      # re-rendered `if ... end` cannot take its place. Only its condition is
+      # mutated, in place; removing a branch is what "replaced condition with
+      # false" already does.
+      def elsif_condition_mutants(node, subject:)
+        condition = node.children.first
+        [[true_node, "replaced condition with true"], [false_node, "replaced condition with false"],
+         [negate(condition), "negated condition"]].map do |replacement, description|
+          build_mutant(subject:, original_node: condition, mutated_node: replacement, description:)
+        end
+      end
+
+      def elsif?(node)
+        node.location.respond_to?(:keyword) && node.location.keyword&.source == "elsif"
+      end
+
       def mutate_case(node, subject:)
         condition = node.children.first
         when_nodes, else_branch = case_children(node.children.drop(1))
@@ -154,8 +172,10 @@ module Henitai
         Parser::AST::Node.new(node.type, children)
       end
 
+      # The parentheses are part of the mutation: `!a > b` would negate only
+      # `a` and compare the boolean, which is not the reported mutant.
       def negate(node)
-        Parser::AST::Node.new(:send, [node, :!])
+        Parser::AST::Node.new(:send, [Parser::AST::Node.new(:begin, [node]), :!])
       end
 
       # rubocop:disable Lint/BooleanSymbol

data/lib/henitai/operators/hash_literal.rb

@@ -9,7 +9,10 @@ module Henitai
     # set) because framework key normalization makes it frequently unkillable
     # (ADR-12).
     class HashLiteral < Henitai::Operator
-      NODE_TYPES = [:hash].freeze
+      # Keyword arguments (kwargs) are mutated like hash literals; the mutant
+      # keeps the node type, so a removed keyword never turns the remaining
+      # ones into a positional hash.
+      NODE_TYPES = %i[hash kwargs].freeze
 
       def self.node_types
         NODE_TYPES
@@ -29,8 +32,8 @@ module Henitai
         build_mutant(
           subject:,
           original_node: node,
-          mutated_node: Parser::AST::Node.new(:hash, []),
-          description: "replaced hash with empty hash"
+          mutated_node: node.updated(nil, []),
+          description: node.type == :kwargs ? "removed keyword arguments" : "replaced hash with empty hash"
         )
       end
 
@@ -52,7 +55,7 @@ module Henitai
 
       def hash_without_pair(node, pair_index)
         remaining = node.children.reject.with_index { |_pair, index| index == pair_index }
-        Parser::AST::Node.new(:hash, remaining)
+        node.updated(nil, remaining)
       end
 
       # Pair keys are always AST nodes (sym/str/…); their first child is the

data/lib/henitai/operators/method_expression.rb

@@ -5,8 +5,11 @@ require_relative "../parser_current"
 module Henitai
   module Operators
     # Replaces generic method call results with nil.
+    #
+    # A call with a block is replaced together with its block: replacing only
+    # the call would leave +nil { ... }+ behind, which does not parse.
     class MethodExpression < Henitai::Operator
-      NODE_TYPES = [:send].freeze
+      NODE_TYPES = %i[send block numblock].freeze
       EXCLUDED_METHODS = %i[
         +
         -
@@ -31,9 +34,10 @@ module Henitai
       end
 
       def mutate(node, subject:)
-        return [] unless node.type == :send
+        call = called_method(node)
+        return [] unless call&.type == :send
 
-        _receiver, method_name, *_arguments = node.children
+        _receiver, method_name, *_arguments = call.children
         return [] if excluded_method?(method_name)
 
         [
@@ -48,6 +52,13 @@ module Henitai
 
       private
 
+      def called_method(node)
+        case node.type
+        when :send then node
+        when :block, :numblock then node.children.first
+        end
+      end
+
       def excluded_method?(method_name)
         method_name.to_s.end_with?("=") || EXCLUDED_METHODS.include?(method_name)
       end

data/lib/henitai/operators/regex_metacharacters.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module Henitai
+  module Operators
+    # Locates the regexp metacharacters that RegexMutator edits.
+    #
+    # An escaped character and the contents of a character class are literal
+    # text: the +^+ in +[^0-9]+ negates the class and is no anchor, and the
+    # +++ in +[+-]+ or +\++ is no quantifier. The scan therefore skips
+    # escapes and tracks character-class nesting, including POSIX brackets
+    # such as +[[:alpha:]]+.
+    class RegexMetacharacters
+      ANCHORS = %w[^ $].freeze
+      QUANTIFIERS = %w[+ * ?].freeze
+      GROUPING = %w[( |].freeze
+
+      def initialize(source)
+        @source = source
+        @found = Hash.new { |hash, key| hash[key] = [] }
+        scan
+      end
+
+      # Indices of the +char+ quantifier ("+" or "*") applied to an atom.
+      def quantifiers(char)
+        @found[[:quantifier, char]].dup
+      end
+
+      # Indices of the +char+ anchor ("^" or "$").
+      def anchors(char)
+        @found[[:anchor, char]].dup
+      end
+
+      # Indices of the opening brackets of top-level, non-negated classes.
+      def class_openers
+        @found[:class_opener].dup
+      end
+
+      private
+
+      def scan
+        @index = 0
+        @depth = 0
+        @previous = nil
+        step while @index < @source.length
+      end
+
+      def step
+        char = @source[@index]
+        if char == "\\"
+          @previous = :atom
+          @index += 2
+        else
+          @depth.positive? ? within_class(char) : top_level(char)
+          @index += 1
+        end
+      end
+
+      def within_class(char)
+        @depth += 1 if char == "["
+        @depth -= 1 if char == "]"
+        @previous = :atom if @depth.zero?
+      end
+
+      def top_level(char)
+        record(char)
+        @previous = kind_of_token(char)
+        @depth = 1 if char == "["
+      end
+
+      def record(char)
+        if ANCHORS.include?(char)
+          @found[[:anchor, char]] << @index
+        elsif char == "["
+          @found[:class_opener] << @index unless @source[@index + 1] == "^"
+        elsif QUANTIFIERS.include?(char) && @previous == :atom
+          @found[[:quantifier, char]] << @index
+        end
+      end
+
+      def kind_of_token(char)
+        return :anchor if ANCHORS.include?(char)
+        return :quantifier if QUANTIFIERS.include?(char) || char == "}"
+        return :group if GROUPING.include?(char)
+
+        :atom
+      end
+    end
+  end
+end

data/lib/henitai/operators/regex_mutator.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "../parser_current"
+require_relative "regex_metacharacters"
 
 module Henitai
   module Operators
@@ -8,7 +9,10 @@ module Henitai
     # and character-class negation.
     #
     # Each applicable transformation yields a separate mutant. Invalid
-    # results (unparseable regex) are discarded before emission.
+    # results (unparseable regex) are discarded before emission. Only static,
+    # single-segment literals are mutated: an interpolated or multi-line
+    # regexp is split into several parts, and rewriting one part alone would
+    # drop or misread the others.
     # Anchor removal and character-class negation are intentionally one-way:
     # they reduce noisy patterns rather than mirroring a full edit matrix.
     class RegexMutator < Henitai::Operator
@@ -30,11 +34,11 @@ module Henitai
       private
 
       def extract_parts(node)
-        str_child  = node.children.find { |c| c.is_a?(Parser::AST::Node) && c.type == :str }
-        opts_node  = node.children.find { |c| c.is_a?(Parser::AST::Node) && c.type == :regopt }
-        return nil unless str_child
+        *parts, opts_node = node.children
+        return unless opts_node.is_a?(Parser::AST::Node) && opts_node.type == :regopt
+        return unless parts.size == 1 && parts.first.is_a?(Parser::AST::Node) && parts.first.type == :str
 
-        [str_child.children[0], opts_node]
+        [parts.first.children[0], opts_node]
       end
 
       def build_regex_mutant(node, opts_node, new_source, original, description, subject:) # rubocop:disable Metrics/ParameterLists
@@ -47,35 +51,26 @@ module Henitai
       end
 
       def transformations(source)
+        found = RegexMetacharacters.new(source)
         [
-          *quantifier_swaps(source),
-          *anchor_removals(source),
-          *char_class_negations(source)
+          [edit(source, found.quantifiers("+"), "*"), "replaced + quantifier with *"],
+          [edit(source, found.quantifiers("*"), "+"), "replaced * quantifier with +"],
+          # Anchors are removed, never added, and character classes are only
+          # negated: the reverse edits would just recreate an input.
+          [edit(source, found.anchors("^").first(1), ""), "removed ^ anchor"],
+          [edit(source, found.anchors("$").last(1), ""), "removed $ anchor"],
+          [insert_after(source, found.class_openers, "^"), "negated character class"]
         ]
       end
 
-      def quantifier_swaps(source)
-        # Quantifier swaps are symmetric. The other transforms are intentionally
-        # one-way because they model reductions instead of reversible edits.
-        [
-          [source.gsub(/(?<=[^*+?\\])\+/, "*"), "replaced + quantifier with *"],
-          [source.gsub(/(?<=[^*+?\\])\*/, "+"), "replaced * quantifier with +"]
-        ]
-      end
-
-      def anchor_removals(source)
-        # Anchors are removed, not added back. The mutation is deliberately
-        # asymmetric because "restoring" anchors would just recreate the input.
-        [
-          [source.sub("^", ""), "removed ^ anchor"],
-          [source.sub(/\$$/, ""), "removed $ anchor"]
-        ]
+      # Replaces the single characters at +indices+, from the last to the
+      # first so earlier indices stay valid.
+      def edit(source, indices, text)
+        indices.sort.reverse.each_with_object(source.dup) { |index, result| result[index] = text }
       end
 
-      def char_class_negations(source)
-        # Negation only flips a positive class into a negated one. We do not
-        # emit the reverse mutation because that would mirror the same edit.
-        [[source.gsub(/\[(?!\^)/, "[^"), "negated character class"]]
+      def insert_after(source, indices, text)
+        indices.sort.reverse.each_with_object(source.dup) { |index, result| result.insert(index + 1, text) }
       end
 
       def valid_regex?(source)

data/lib/henitai/operators/return_value.rb

@@ -47,7 +47,7 @@ module Henitai
       end
 
       def mutate_implicit_return(node, subject:)
-        return [] unless node == final_expression_node(subject&.ast_node)
+        return [] unless node.equal?(final_expression_node(subject&.ast_node))
 
         replacement_nodes(node).map do |replacement|
           build_mutant(

data/lib/henitai/operators.rb

@@ -24,6 +24,7 @@ module Henitai
     autoload :MethodExpression, "henitai/operators/method_expression"
     autoload :AssignmentExpression, "henitai/operators/assignment_expression"
     autoload :MethodChainUnwrap,    "henitai/operators/method_chain_unwrap"
+    autoload :RegexMetacharacters,  "henitai/operators/regex_metacharacters"
     autoload :RegexMutator,         "henitai/operators/regex_mutator"
     autoload :UnaryOperator,        "henitai/operators/unary_operator"
     autoload :UpdateOperator,       "henitai/operators/update_operator"