mutant 0.11.16 → 0.11.18

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mutant
 version: !ruby/object:Gem::Version
-  version: 0.11.16
+  version: 0.11.18
 platform: ruby
 authors:
 - Markus Schirp
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-09-11 00:00:00.000000000 Z
+date: 2023-01-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: diff-lcs
@@ -30,34 +30,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 3.1.0
+        version: 3.2.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 3.1.0
+        version: 3.2.0
 - !ruby/object:Gem::Dependency
   name: regexp_parser
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.3'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 2.3.1
+        version: 2.6.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.3'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 2.3.1
+        version: 2.6.1
 - !ruby/object:Gem::Dependency
   name: sorbet-runtime
   requirement: !ruby/object:Gem::Requirement
@@ -78,14 +72,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.6.5
+        version: 0.6.6
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.6.5
+        version: 0.6.6
 - !ruby/object:Gem::Dependency
   name: parallel
   requirement: !ruby/object:Gem::Requirement
@@ -184,15 +178,6 @@ files:
 - lib/mutant/ast/pattern/parser.rb
 - lib/mutant/ast/pattern/source.rb
 - lib/mutant/ast/pattern/token.rb
-- lib/mutant/ast/regexp.rb
-- lib/mutant/ast/regexp/transformer.rb
-- lib/mutant/ast/regexp/transformer/direct.rb
-- lib/mutant/ast/regexp/transformer/named_group.rb
-- lib/mutant/ast/regexp/transformer/options_group.rb
-- lib/mutant/ast/regexp/transformer/quantifier.rb
-- lib/mutant/ast/regexp/transformer/recursive.rb
-- lib/mutant/ast/regexp/transformer/root.rb
-- lib/mutant/ast/regexp/transformer/text.rb
 - lib/mutant/ast/sexp.rb
 - lib/mutant/ast/structure.rb
 - lib/mutant/ast/types.rb
@@ -297,15 +282,6 @@ files:
 - lib/mutant/mutator/node/op_asgn.rb
 - lib/mutant/mutator/node/or_asgn.rb
 - lib/mutant/mutator/node/procarg_zero.rb
-- lib/mutant/mutator/node/regexp.rb
-- lib/mutant/mutator/node/regexp/alternation_meta.rb
-- lib/mutant/mutator/node/regexp/beginning_of_line_anchor.rb
-- lib/mutant/mutator/node/regexp/capture_group.rb
-- lib/mutant/mutator/node/regexp/character_type.rb
-- lib/mutant/mutator/node/regexp/end_of_line_anchor.rb
-- lib/mutant/mutator/node/regexp/end_of_string_or_before_end_of_line_anchor.rb
-- lib/mutant/mutator/node/regexp/named_group.rb
-- lib/mutant/mutator/node/regexp/zero_or_more.rb
 - lib/mutant/mutator/node/regopt.rb
 - lib/mutant/mutator/node/resbody.rb
 - lib/mutant/mutator/node/rescue.rb
@@ -320,6 +296,7 @@ files:
 - lib/mutant/mutator/node/when.rb
 - lib/mutant/mutator/node/yield.rb
 - lib/mutant/mutator/node/zsuper.rb
+- lib/mutant/mutator/regexp.rb
 - lib/mutant/mutator/util.rb
 - lib/mutant/mutator/util/array.rb
 - lib/mutant/mutator/util/symbol.rb
@@ -356,6 +333,8 @@ files:
 - lib/mutant/runner.rb
 - lib/mutant/runner/sink.rb
 - lib/mutant/scope.rb
+- lib/mutant/segment.rb
+- lib/mutant/segment/recorder.rb
 - lib/mutant/selector.rb
 - lib/mutant/selector/expression.rb
 - lib/mutant/selector/null.rb
@@ -393,7 +372,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.7
+rubygems_version: 3.3.26
 signing_key:
 specification_version: 4
 summary: ''

data/lib/mutant/ast/regexp/transformer/direct.rb

@@ -1,145 +0,0 @@
-# frozen_string_literal: true
-
-module Mutant
-  class AST
-    module Regexp
-      class Transformer
-        # Transformer for nodes which map directly to other domain
-        #
-        # A node maps "directly" to another domain if the node never
-        # has children or text which needs to be preserved for a mapping
-        #
-        # @example direct mapping
-        #
-        #     input      = /\d/
-        #     expression = Regexp::Parser.parse(input).first
-        #     node       = Transformer::Direct.to_ast(expression)
-        #
-        #     # the digit type always has the same text and no children
-        #     expression.text      # => "\\d"
-        #     expression.terminal? # => true
-        #
-        #     # therefore the `Parser::AST::Node` is always the same
-        #     node # => s(:regexp_digit_type)
-        class Direct < self
-          # Mapper from `Regexp::Expression` to `Parser::AST::Node`
-          class ExpressionToAST < Transformer::ExpressionToAST
-            # Transform expression into node
-            #
-            # @return [Parser::AST::Node]
-            def call
-              quantify(ast)
-            end
-          end # ExpressionToAST
-
-          # Mapper from `Parser::AST::Node` to `Regexp::Expression`
-          class ASTToExpression < Transformer::ASTToExpression
-            include LookupTable
-
-            properties = ::Regexp::Syntax
-              .version_class("ruby/#{RUBY_VERSION}")
-              .features.fetch(:property)
-              .flat_map do |property|
-                property_specifier      = "\\p{#{property}}"
-                non_property_specifier  = "\\P{#{property}}"
-
-                property_regex     = /#{property_specifier}/
-                non_property_regex = /#{non_property_specifier}/
-
-                [
-                  [
-                    :"regexp_#{property}_property",
-                    [
-                      :property,
-                      property.to_sym,
-                      property_specifier
-                    ],
-                    ::Regexp::Parser.parse(property_regex).expressions.first.class
-                  ],
-                  [
-                    :"regexp_#{property}_nonproperty",
-                    [
-                      :nonproperty,
-                      property.to_sym,
-                      non_property_specifier
-                    ],
-                    ::Regexp::Parser.parse(non_property_regex).expressions.first.class
-                  ]
-                ]
-            end
-
-            # rubocop:disable Layout/LineLength
-            TABLE = Table.create(
-              *properties,
-              [:regexp_alnum_posixclass,         [:posixclass,    :alnum,            '[:alnum:]'],    ::Regexp::Expression::PosixClass],
-              [:regexp_alpha_posixclass,         [:posixclass,    :alpha,            '[:alpha:]'],    ::Regexp::Expression::PosixClass],
-              [:regexp_alternation_escape,       [:escape,        :alternation,      '\|'],           ::Regexp::Expression::EscapeSequence::Literal],
-              [:regexp_ascii_posixclass,         [:posixclass,    :ascii,            '[:ascii:]'],    ::Regexp::Expression::PosixClass],
-              [:regexp_backspace_escape,         [:escape,        :backspace,        '\b'],           ::Regexp::Expression::EscapeSequence::Backspace],
-              [:regexp_bell_escape,              [:escape,        :bell,             '\a'],           ::Regexp::Expression::EscapeSequence::Literal],
-              [:regexp_blank_posixclass,         [:posixclass,    :blank,            '[:blank:]'],    ::Regexp::Expression::PosixClass],
-              [:regexp_bol_anchor,               [:anchor,        :bol,              '^'],            ::Regexp::Expression::Anchor::BeginningOfLine],
-              [:regexp_bol_escape,               [:escape,        :bol,              '\^'],           ::Regexp::Expression::EscapeSequence::Literal],
-              [:regexp_bos_anchor,               [:anchor,        :bos,              '\\A'],          ::Regexp::Expression::Anchor::BeginningOfString],
-              [:regexp_carriage_escape,          [:escape,        :carriage,         '\r'],           ::Regexp::Expression::EscapeSequence::Literal],
-              [:regexp_cntrl_posixclass,         [:posixclass,    :cntrl,            '[:cntrl:]'],    ::Regexp::Expression::PosixClass],
-              [:regexp_digit_posixclass,         [:posixclass,    :digit,            '[:digit:]'],    ::Regexp::Expression::PosixClass],
-              [:regexp_digit_type,               [:type,          :digit,            '\d'],           ::Regexp::Expression::CharacterType::Digit],
-              [:regexp_dot_escape,               [:escape,        :dot,              '\.'],           ::Regexp::Expression::EscapeSequence::Literal],
-              [:regexp_dot_meta,                 [:meta,          :dot,              '.'],            ::Regexp::Expression::CharacterType::Any],
-              [:regexp_eol_anchor,               [:anchor,        :eol,              '$'],            ::Regexp::Expression::Anchor::EndOfLine],
-              [:regexp_eol_escape,               [:escape,        :eol,              '\$'],           ::Regexp::Expression::EscapeSequence::Literal],
-              [:regexp_eos_anchor,               [:anchor,        :eos,              '\\z'],          ::Regexp::Expression::Anchor::EndOfString],
-              [:regexp_eos_ob_eol_anchor,        [:anchor,        :eos_ob_eol,       '\\Z'],          ::Regexp::Expression::Anchor::EndOfStringOrBeforeEndOfLine],
-              [:regexp_escape_escape,            [:escape,        :escape,           '\e'],           ::Regexp::Expression::EscapeSequence::AsciiEscape],
-              [:regexp_form_feed_escape,         [:escape,        :form_feed,        '\f'],           ::Regexp::Expression::EscapeSequence::FormFeed],
-              [:regexp_graph_posixclass,         [:posixclass,    :graph,            '[:graph:]'],    ::Regexp::Expression::PosixClass],
-              [:regexp_group_close_escape,       [:escape,        :group_close,      '\)'],           ::Regexp::Expression::EscapeSequence::Literal],
-              [:regexp_group_open_escape,        [:escape,        :group_open,       '\('],           ::Regexp::Expression::EscapeSequence::Literal],
-              [:regexp_hex_type,                 [:type,          :hex,              '\h'],           ::Regexp::Expression::CharacterType::Hex],
-              [:regexp_interval_close_escape,    [:escape,        :interval_close,   '\}'],           ::Regexp::Expression::EscapeSequence::Literal],
-              [:regexp_interval_open_escape,     [:escape,        :interval_open,    '\{'],           ::Regexp::Expression::EscapeSequence::Literal],
-              [:regexp_linebreak_type,           [:type,          :linebreak,        '\R'],           ::Regexp::Expression::CharacterType::Linebreak],
-              [:regexp_lower_posixclass,         [:posixclass,    :lower,            '[:lower:]'],    ::Regexp::Expression::PosixClass],
-              [:regexp_mark_keep,                [:keep,          :mark,             '\K'],           ::Regexp::Expression::Keep::Mark],
-              [:regexp_match_start_anchor,       [:anchor,        :match_start,      '\\G'],          ::Regexp::Expression::Anchor::MatchStart],
-              [:regexp_newline_escape,           [:escape,        :newline,          '\n'],           ::Regexp::Expression::EscapeSequence::Literal],
-              [:regexp_nondigit_type,            [:type,          :nondigit,         '\D'],           ::Regexp::Expression::CharacterType::NonDigit],
-              [:regexp_nonhex_type,              [:type,          :nonhex,           '\H'],           ::Regexp::Expression::CharacterType::NonHex],
-              [:regexp_nonspace_type,            [:type,          :nonspace,         '\S'],           ::Regexp::Expression::CharacterType::NonSpace],
-              [:regexp_nonword_boundary_anchor,  [:anchor,        :nonword_boundary, '\\B'],          ::Regexp::Expression::Anchor::NonWordBoundary],
-              [:regexp_nonword_type,             [:type,          :nonword,          '\W'],           ::Regexp::Expression::CharacterType::NonWord],
-              [:regexp_one_or_more_escape,       [:escape,        :one_or_more,      '\+'],           ::Regexp::Expression::EscapeSequence::Literal],
-              [:regexp_print_nonposixclass,      [:nonposixclass, :print,            '[:^print:]'],   ::Regexp::Expression::PosixClass],
-              [:regexp_print_posixclass,         [:posixclass,    :print,            '[:print:]'],    ::Regexp::Expression::PosixClass],
-              [:regexp_print_posixclass,         [:posixclass,    :print,            '[:print:]'],    ::Regexp::Expression::PosixClass],
-              [:regexp_punct_posixclass,         [:posixclass,    :punct,            '[:punct:]'],    ::Regexp::Expression::PosixClass],
-              [:regexp_set_close_escape,         [:escape,        :set_close,        '\]'],           ::Regexp::Expression::EscapeSequence::Literal],
-              [:regexp_set_open_escape,          [:escape,        :set_open,         '\['],           ::Regexp::Expression::EscapeSequence::Literal],
-              [:regexp_space_posixclass,         [:posixclass,    :space,            '[:space:]'],    ::Regexp::Expression::PosixClass],
-              [:regexp_space_type,               [:type,          :space,            '\s'],           ::Regexp::Expression::CharacterType::Space],
-              [:regexp_upper_posixclass,         [:posixclass,    :upper,            '[:upper:]'],    ::Regexp::Expression::PosixClass],
-              [:regexp_vertical_tab_escape,      [:escape,        :vertical_tab,     '\v'],           ::Regexp::Expression::EscapeSequence::VerticalTab],
-              [:regexp_word_boundary_anchor,     [:anchor,        :word_boundary,    '\b'],           ::Regexp::Expression::Anchor::WordBoundary],
-              [:regexp_word_posixclass,          [:posixclass,    :word,             '[:word:]'],     ::Regexp::Expression::PosixClass],
-              [:regexp_word_type,                [:type,          :word,             '\w'],           ::Regexp::Expression::CharacterType::Word],
-              [:regexp_xdigit_posixclass,        [:posixclass,    :xdigit,           '[:xdigit:]'],   ::Regexp::Expression::PosixClass],
-              [:regexp_xgrapheme_type,           [:type,          :xgrapheme,        '\X'],           ::Regexp::Expression::CharacterType::ExtendedGrapheme],
-              [:regexp_zero_or_more_escape,      [:escape,        :zero_or_more,     '\*'],           ::Regexp::Expression::EscapeSequence::Literal],
-              [:regexp_zero_or_one_escape,       [:escape,        :zero_or_one,      '\?'],           ::Regexp::Expression::EscapeSequence::Literal]
-            )
-          # rubocop:enable Layout/LineLength
-
-          private
-
-            def transform
-              expression_class.new(expression_token)
-            end
-          end # ASTToExpression
-
-          ASTToExpression::TABLE.types.each(&method(:register))
-        end # Direct
-      end # Transformer
-    end # Regexp
-  end # AST
-end # Mutant

data/lib/mutant/ast/regexp/transformer/named_group.rb

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-module Mutant
-  class AST
-    module Regexp
-      class Transformer
-        # Transformer for named groups
-        class NamedGroup < self
-          register :regexp_named_group
-
-          # Mapper from `Regexp::Expression` to `Parser::AST::Node`
-          class ExpressionToAST < Transformer::ExpressionToAST
-
-            # Transform named group into node
-            #
-            # @return [Parser::AST::Node]
-            def call
-              quantify(ast(expression.name, *children))
-            end
-          end # ExpressionToAST
-
-          # Mapper from `Parser::AST::Node` to `Regexp::Expression`
-          class ASTToExpression < Transformer::ASTToExpression
-            include NamedChildren
-
-            children :name
-
-          private
-
-            def transform
-              named_group.tap do |expression|
-                expression.expressions = subexpressions
-              end
-            end
-
-            def subexpressions
-              remaining_children.map(&Regexp.public_method(:to_expression))
-            end
-
-            def named_group
-              ::Regexp::Expression::Group::Named.new(
-                ::Regexp::Token.new(:group, :named, "(?<#{name}>")
-              )
-            end
-          end # ASTToExpression
-        end # NamedGroup
-      end # Transformer
-    end # Regexp
-  end # AST
-end # Mutant

data/lib/mutant/ast/regexp/transformer/options_group.rb

@@ -1,68 +0,0 @@
-# frozen_string_literal: true
-
-module Mutant
-  class AST
-    module Regexp
-      class Transformer
-        # Transformer for option groups
-        class OptionsGroup < self
-          register :regexp_options_group
-          register :regexp_options_switch_group
-
-          # Mapper from `Regexp::Expression` to `Parser::AST::Node`
-          class ExpressionToAST < Transformer::ExpressionToAST
-
-            # Transform options group into node
-            #
-            # @return [Parser::AST::Node]
-            def call
-              quantify(ast(expression.option_changes, *children))
-            end
-          end # ExpressionToAST
-
-          # Mapper from `Parser::AST::Node` to `Regexp::Expression`
-          class ASTToExpression < Transformer::ASTToExpression
-            include NamedChildren
-
-            children :option_changes
-
-          private
-
-            def transform
-              options_group.tap do |expression|
-                expression.expressions = subexpressions
-              end
-            end
-
-            def subexpressions
-              remaining_children.map(&Regexp.public_method(:to_expression))
-            end
-
-            def options_group
-              ::Regexp::Expression::Group::Options.new(
-                ::Regexp::Token.new(:group, type, text)
-              )
-            end
-
-            def type
-              {
-                regexp_options_group:        :options,
-                regexp_options_switch_group: :options_switch
-              }.fetch(node.type)
-            end
-
-            def text
-              pos, neg = option_changes.partition { |_opt, val| val }.map do |arr|
-                arr.map(&:first).join
-              end
-              neg_opt_sep = '-' unless neg.empty?
-              content_sep = ':' unless type.equal?(:options_switch)
-
-              "(?#{pos}#{neg_opt_sep}#{neg}#{content_sep}"
-            end
-          end # ASTToExpression
-        end # OptionsGroup
-      end # Transformer
-    end # Regexp
-  end # AST
-end # Mutant

data/lib/mutant/ast/regexp/transformer/quantifier.rb

@@ -1,92 +0,0 @@
-# frozen_string_literal: true
-
-module Mutant
-  class AST
-    module Regexp
-      class Transformer
-        # Transformer for regexp quantifiers
-        class Quantifier < self
-          # Mapper from `Regexp::Expression` to `Parser::AST::Node`
-          class ExpressionToAST < Transformer::ExpressionToAST
-            # Transform quantifier into node
-            #
-            # @return [Parser::AST::Node]
-            def call
-              ast(expression.min, expression.max)
-            end
-
-          private
-
-            def type
-              :"regexp_#{expression.mode}_#{expression.token}"
-            end
-          end # ExpressionToAST
-
-          # Mapper from `Parser::AST::Node` to `Regexp::Expression`
-          class ASTToExpression < Transformer::ASTToExpression
-            include NamedChildren
-
-            children :min, :max, :subject
-
-            Quantifier = Class.new.include(Concord::Public.new(:type, :suffix, :mode))
-
-            QUANTIFIER_MAP = {
-              regexp_greedy_zero_or_more:     [:zero_or_more, '*',  :greedy],
-              regexp_greedy_one_or_more:      [:one_or_more,  '+',  :greedy],
-              regexp_greedy_zero_or_one:      [:zero_or_one,  '?',  :greedy],
-              regexp_possessive_zero_or_one:  [:zero_or_one,  '?+', :possessive],
-              regexp_reluctant_zero_or_more:  [:zero_or_more, '*?', :reluctant],
-              regexp_reluctant_one_or_more:   [:one_or_more,  '+?', :reluctant],
-              regexp_possessive_zero_or_more: [:zero_or_more, '*+', :possessive],
-              regexp_possessive_one_or_more:  [:one_or_more,  '++', :possessive],
-              regexp_greedy_interval:         [:interval,     '',   :greedy],
-              regexp_reluctant_interval:      [:interval,     '?',  :reluctant],
-              regexp_possessive_interval:     [:interval,     '+',  :possessive]
-            }.transform_values { |arguments| Quantifier.new(*arguments) }
-              .to_h
-              .freeze
-
-          private
-
-            def transform
-              Regexp.to_expression(subject).dup.tap do |expression|
-                expression.quantify(type, text, min, max, mode)
-              end
-            end
-
-            def text
-              if type.equal?(:interval)
-                interval_text + suffix
-              else
-                suffix
-              end
-            end
-
-            def type
-              quantifier.type
-            end
-
-            def suffix
-              quantifier.suffix
-            end
-
-            def mode
-              quantifier.mode
-            end
-
-            def quantifier
-              QUANTIFIER_MAP.fetch(node.type)
-            end
-
-            def interval_text
-              interval = [min, max].map { |num| num if num.positive? }.uniq
-              "{#{interval.join(',')}}"
-            end
-          end # ASTToExpression
-
-          ASTToExpression::QUANTIFIER_MAP.keys.each(&method(:register))
-        end # Quantifier
-      end # Transformer
-    end # Regexp
-  end # AST
-end # Mutant

data/lib/mutant/ast/regexp/transformer/recursive.rb

@@ -1,56 +0,0 @@
-# frozen_string_literal: true
-
-module Mutant
-  class AST
-    module Regexp
-      class Transformer
-        # Transformer for nodes with children
-        class Recursive < self
-          # Mapper from `Regexp::Expression` to `Parser::AST::Node`
-          class ExpressionToAST < Transformer::ExpressionToAST
-            # Transform expression and children into nodes
-            #
-            # @return [Parser::AST::Node]
-            def call
-              quantify(ast(*children))
-            end
-          end # ExpressionToAST
-
-          # Mapper from `Parser::AST::Node` to `Regexp::Expression`
-          class ASTToExpression < Transformer::ASTToExpression
-            include LookupTable
-
-            # Expression::Sequence represents conditional branches, alternation branches, and intersection branches
-            # rubocop:disable Layout/LineLength
-            TABLE = Table.create(
-              [:regexp_alternation_meta,      [:meta,        :alternation,  '|'],    ::Regexp::Expression::Alternation],
-              [:regexp_atomic_group,          [:group,       :atomic,       '(?>'],  ::Regexp::Expression::Group::Atomic],
-              [:regexp_capture_group,         [:group,       :capture,      '('],    ::Regexp::Expression::Group::Capture],
-              [:regexp_character_set,         [:set,         :character,    '['],    ::Regexp::Expression::CharacterSet],
-              [:regexp_intersection_set,      [:set,         :intersection, '&&'],   ::Regexp::Expression::CharacterSet::Intersection],
-              [:regexp_lookahead_assertion,   [:assertion,   :lookahead,    '(?='],  ::Regexp::Expression::Assertion::Lookahead],
-              [:regexp_lookbehind_assertion,  [:assertion,   :lookbehind,   '(?<='], ::Regexp::Expression::Assertion::Lookbehind],
-              [:regexp_nlookahead_assertion,  [:assertion,   :nlookahead,   '(?!'],  ::Regexp::Expression::Assertion::NegativeLookahead],
-              [:regexp_nlookbehind_assertion, [:assertion,   :nlookbehind,  '(?<!'], ::Regexp::Expression::Assertion::NegativeLookbehind],
-              [:regexp_open_conditional,      [:conditional, :open,         '(?'],   ::Regexp::Expression::Conditional::Expression],
-              [:regexp_passive_group,         [:group,       :passive,      '(?:'],  ::Regexp::Expression::Group::Passive],
-              [:regexp_range_set,             [:set,         :range,        '-'],    ::Regexp::Expression::CharacterSet::Range],
-              [:regexp_sequence_expression,   [:expression,  :sequence,     ''],     ::Regexp::Expression::Sequence]
-            )
-          # rubocop:enable Layout/LineLength
-
-          private
-
-            def transform
-              expression_class.new(expression_token).tap do |expression|
-                expression.expressions = subexpressions
-              end
-            end
-          end # ASTToExpression
-
-          ASTToExpression::TABLE.types.each(&method(:register))
-        end # Recursive
-      end # Transformer
-    end # Regexp
-  end # AST
-end # Mutant

data/lib/mutant/ast/regexp/transformer/root.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-module Mutant
-  class AST
-    module Regexp
-      class Transformer
-        # Transformer for root nodes
-        class Root < self
-          register :regexp_root_expression
-
-          ExpressionToAST = Class.new(Recursive::ExpressionToAST)
-
-          # Mapper from `Parser::AST::Node` to `Regexp::Expression`
-          class ASTToExpression < Transformer::ASTToExpression
-
-          private
-
-            def transform
-              ::Regexp::Expression::Root.build.tap do |root|
-                root.expressions = subexpressions
-              end
-            end
-          end # ASTToExpression
-        end # Root
-      end # Transformer
-    end # Regexp
-  end # AST
-end # Mutant

data/lib/mutant/ast/regexp/transformer/text.rb

@@ -1,58 +0,0 @@
-# frozen_string_literal: true
-
-module Mutant
-  class AST
-    module Regexp
-      class Transformer
-        # Regexp AST transformer for nodes that encode a text value
-        class Text < self
-          # Mapper from `Regexp::Expression` to `Parser::AST::Node`
-          class ExpressionToAST < Transformer::ExpressionToAST
-            # Transform expression into node preserving text value
-            #
-            # @return [Parser::AST::Node]
-            def call
-              quantify(ast(expression.text))
-            end
-          end # ExpressionToAST
-
-          # Mapper from `Parser::AST::Node` to `Regexp::Expression`
-          class ASTToExpression < Transformer::ASTToExpression
-            include LookupTable
-
-            # rubocop:disable Layout/LineLength
-            TABLE = Table.create(
-              [:regexp_literal_literal,       %i[literal literal],       ::Regexp::Expression::Literal],
-              [:regexp_comment_group,         %i[group comment],         ::Regexp::Expression::Group::Comment],
-              [:regexp_number_backref,        %i[backref number],        ::Regexp::Expression::Backreference::Number],
-              [:regexp_name_call_backref,     %i[backref name_call],     ::Regexp::Expression::Backreference::NameCall],
-              [:regexp_whitespace_free_space, %i[free_space whitespace], ::Regexp::Expression::WhiteSpace],
-              [:regexp_comment_free_space,    %i[free_space comment],    ::Regexp::Expression::WhiteSpace],
-              [:regexp_hex_escape,            %i[escape hex],            ::Regexp::Expression::EscapeSequence::Hex],
-              [:regexp_octal_escape,          %i[escape octal],          ::Regexp::Expression::EscapeSequence::Octal],
-              [:regexp_literal_escape,        %i[escape literal],        ::Regexp::Expression::EscapeSequence::Literal],
-              [:regexp_backslash_escape,      %i[escape backslash],      ::Regexp::Expression::EscapeSequence::Literal],
-              [:regexp_tab_escape,            %i[escape tab],            ::Regexp::Expression::EscapeSequence::Literal],
-              [:regexp_codepoint_list_escape, %i[escape codepoint_list], ::Regexp::Expression::EscapeSequence::CodepointList],
-              [:regexp_codepoint_escape,      %i[escape codepoint],      ::Regexp::Expression::EscapeSequence::Codepoint],
-              [:regexp_control_escape,        %i[escape control],        ::Regexp::Expression::EscapeSequence::Control],
-              [:regexp_meta_sequence_escape,  %i[escape meta_sequence],  ::Regexp::Expression::EscapeSequence::Control],
-              [:regexp_condition_conditional, %i[conditional condition], ::Regexp::Expression::Conditional::Condition]
-            )
-          # rubocop:enable Layout/LineLength
-
-          private
-
-            def transform
-              token = expression_token.dup
-              token.text = Util.one(node.children)
-              expression_class.new(token)
-            end
-          end # ASTToExpression
-
-          ASTToExpression::TABLE.types.each(&method(:register))
-        end # Text
-      end # Transformer
-    end # Regexp
-  end # AST
-end # Mutant