mutant 0.11.17 → 0.11.18

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 32bc27a55a33df968de61bde922b6318d158bf5f3ab0d3676720e2ba8e9ac2db
-  data.tar.gz: 20a7a9db2b3a034d9579bca78bfcca98d3e25117937407696bad239263c3b402
+  metadata.gz: 327c0520e73601c447d4081b428de0111e59627961c82a955e86b2015fef7ce7
+  data.tar.gz: 93dd7338a29a416bce5025d8c95a39cb88cc5e96932435797b60102689726e3d
 SHA512:
-  metadata.gz: 4297d6e5172b74dc1e776739c68a5980cbda44581e38b06f76ed2ee395b816b2d664e146b98ac8c9a5f25e31e2b6078016398db862d0b96675299fbc3bc2cc49
-  data.tar.gz: f899277fb892b69bfac0b988e84fb9955036ea415cf2c55fecb90976bc3cdd9dd249d5bac1c154039df3c8af37db04b2d2d0c97003eac01c539371a7c9804d41
+  metadata.gz: 433b57a38e8b5d68f579d26cb5352cabc222137eb875183364dcd1f39ff8852c8a7f2a95b7ee64a3258ed87f9620670160d8d98df6b0a4513e174ff4b8775a6d
+  data.tar.gz: 84b5b86c80958651592da077cfbd5e965587ce02b05c9b27fc9cf86506a80f963351011cf4ebfe23e084ab211a2f9ea2ac6e89f0efcfeb90cc019a28ab42a0b1

data/lib/mutant/bootstrap.rb

@@ -113,7 +113,7 @@ module Mutant
       env.record(__method__) do
         config = env.config
 
-        scopes = env.world.object_space.each_object(Module).each_with_object([]) do |scope, aggregate|
+        scopes = env.world.object_space.each_object(Module).with_object([]) do |scope, aggregate|
           expression = expression(config.reporter, config.expression_parser, scope) || next
           aggregate << Scope.new(scope, expression)
         end

data/lib/mutant/cli/command/environment/run.rb

@@ -41,7 +41,7 @@ module Mutant
           end
 
           def validate_tests(environment)
-            if environment.integration.all_tests.length.zero?
+            if environment.integration.all_tests.empty?
               Either::Left.new(NO_TESTS_MESSAGE)
             else
               Either::Right.new(environment)

data/lib/mutant/mutator/node/literal/regex.rb

@@ -29,17 +29,17 @@ module Mutant
           end
 
           def mutate_body
-            # NOTE: will only mutate parts of regexp body if the body is composed of only strings.
-            # Regular expressions with interpolation are skipped.
-            return unless (body_ast = AST::Regexp.expand_regexp_ast(input))
+            string = Regexp.regexp_body(input) or return
 
-            mutate(node: body_ast).each do |mutation|
-              source = AST::Regexp.to_expression(mutation).to_s
-              emit_type(s(:str, source), options)
-            end
+            Regexp
+              .mutate(::Regexp::Parser.parse(string))
+              .each(&method(:emit_regexp_body))
           end
 
-        end # Regex
+          def emit_regexp_body(expression)
+            emit_type(s(:str, expression.to_str), options)
+          end
+        end # Regexp
       end # Literal
     end # Node
   end # Mutator

data/lib/mutant/mutator/node/send.rb

@@ -50,9 +50,19 @@ module Mutant
           }.freeze
         }.freeze
 
-        REGEXP_MATCH_METHODS    = %i[=~ match match?].freeze
-        REGEXP_START_WITH_NODES = %i[regexp_bos_anchor regexp_literal_literal].freeze
-        REGEXP_END_WITH_NODES   = %i[regexp_literal_literal regexp_eos_anchor].freeze
+        REGEXP_MATCH_METHODS = %i[=~ match match?].freeze
+
+        REGEXP_START_WITH_NODES =
+          [
+            ::Regexp::Expression::Anchor::BeginningOfString,
+            ::Regexp::Expression::Literal
+          ].freeze
+
+        REGEXP_END_WITH_NODES =
+          [
+            ::Regexp::Expression::Literal,
+            ::Regexp::Expression::Anchor::EndOfString
+          ].freeze
 
       private
 
@@ -114,33 +124,33 @@ module Mutant
           end
         end
 
-        def emit_start_end_with_mutations # rubocop:disable Metrics/CyclomaticComplexity, Metrics/MethodLength
+        # rubocop:disable Metrics/CyclomaticComplexity
+        # rubocop:disable Metrics/MethodLength
+        def emit_start_end_with_mutations
           return unless REGEXP_MATCH_METHODS.include?(selector) && arguments.one?
 
           argument = Mutant::Util.one(arguments)
 
-          return unless argument.type.equal?(:regexp) && (
-            regexp_ast = AST::Regexp.expand_regexp_ast(argument)
-          )
+          return unless argument.type.equal?(:regexp)
+
+          string = Regexp.regexp_body(argument) or return
 
-          regexp_children = regexp_ast.children
+          expressions = ::Regexp::Parser.parse(string)
 
-          case regexp_children.map(&:type)
+          case expressions.map(&:class)
           when REGEXP_START_WITH_NODES
-            emit_start_with(regexp_children)
+            emit_start_with(expressions.last.text)
           when REGEXP_END_WITH_NODES
-            emit_end_with(regexp_children)
+            emit_end_with(expressions.first.text)
           end
         end
 
-        def emit_start_with(regexp_nodes)
-          literal = Mutant::Util.one(regexp_nodes.last.children)
-          emit_type(receiver, :start_with?, s(:str, literal))
+        def emit_start_with(string)
+          emit_type(receiver, :start_with?, s(:str, string))
         end
 
-        def emit_end_with(regexp_nodes)
-          literal = Mutant::Util.one(regexp_nodes.first.children)
-          emit_type(receiver, :end_with?, s(:str, literal))
+        def emit_end_with(string)
+          emit_type(receiver, :end_with?, s(:str, string))
         end
 
         def emit_predicate_mutations

data/lib/mutant/mutator/regexp.rb

@@ -0,0 +1,211 @@
+# frozen_string_literal: true
+
+module Mutant
+  class Mutator
+    class Regexp < self
+      def self.regexp_body(node)
+        *body, _options = node.children
+
+        body.map do |child|
+          return unless child.type.equal?(:str)
+          child.children
+        end.join
+      end
+
+      class Registry
+        include Concord.new(:contents)
+
+        def initialize
+          super({})
+        end
+
+        def register(expression_class, mutator_class)
+          (contents[expression_class] ||= []) << mutator_class
+          self
+        end
+
+        def lookup(expression_class)
+          contents.fetch(expression_class, []).push(Quantifier)
+        end
+      end # Registry
+
+      REGISTRY = Registry.new
+
+      # mutant:disable - boot time code
+      def self.handle(*types)
+        types.each do |type|
+          self::REGISTRY.register(type, self)
+        end
+      end
+
+      private_class_method :handle
+
+      def self.mutate(expression)
+        REGISTRY
+          .lookup(expression.class)
+          .map { |mutator| mutator.call(input: expression, parent: nil) }
+          .reduce(&:merge)
+      end
+
+   private
+
+      def subexpressions
+        input.expressions
+      end
+
+      def mk_dup
+        Marshal.load(Marshal.dump(input))
+      end
+
+      def emit_expression(klass:, text:)
+        emit(
+          klass.construct(text: text).tap do |new|
+            subexpressions.each do |expression|
+              new << Marshal.load(Marshal.dump(expression))
+            end
+          end
+        )
+      end
+
+      def emit_passive_group
+        emit_expression(
+          klass: ::Regexp::Expression::Group::Passive,
+          text:  '(?:'
+        )
+      end
+
+      class Alternation < self
+        handle(::Regexp::Expression::Alternation)
+
+        def dispatch
+          subexpressions.each_index do |index|
+            emit(mk_dup.tap { |new| new.expressions.delete_at(index) })
+          end
+        end
+      end
+
+      class Quantifier < self
+        MAP = {
+          '*'  => '+',
+          '*+' => '++',
+          '*?' => '+?'
+        }.freeze
+
+        def dispatch
+          return unless input.quantifier
+
+          emit_removal
+          emit_replacement
+        end
+
+        def emit_removal
+          emit(mk_dup.tap { |new| new.quantifier = nil })
+        end
+
+        def emit_replacement
+          new_text = MAP[input.quantifier.text]
+
+          emit(mk_dup.tap { |new| new.quantifier.text = new_text })
+        end
+      end
+
+      class Replacement < self
+        ns = ::Regexp::Expression
+
+        dual_table =
+          [
+            [ns::Anchor::WordBoundary,            '\\b', ns::Anchor::NonWordBoundary,  '\\B'],
+            [ns::CharacterType::Digit,            '\\d', ns::CharacterType::NonDigit,  '\\D'],
+            [ns::CharacterType::ExtendedGrapheme, '\\X', ns::CharacterType::Linebreak, '\\R'],
+            [ns::CharacterType::Hex,              '\\h', ns::CharacterType::NonHex,    '\\H'],
+            [ns::CharacterType::Space,            '\\s', ns::CharacterType::NonSpace,  '\\S'],
+            [ns::CharacterType::Word,             '\\w', ns::CharacterType::NonWord,   '\\W']
+          ]
+
+        MAP = dual_table.flat_map do |(left_key, left_text, right_key, right_text)|
+          [
+            [left_key,  [right_key, right_text]],
+            [right_key, [left_key,  left_text]]
+          ]
+        end.to_h
+
+        MAP[ns::Anchor::BeginningOfLine]              = [ns::Anchor::BeginningOfString, '\\A']
+        MAP[ns::Anchor::EndOfLine]                    = [ns::Anchor::EndOfString, '\\z']
+        MAP[ns::Anchor::EndOfStringOrBeforeEndOfLine] = [ns::Anchor::EndOfString, '\\z']
+
+        MAP.freeze
+
+        handle(*MAP.keys)
+
+        def dispatch
+          klass, text = MAP.fetch(input.class)
+
+          emit(klass.construct(text: text).tap { |new| new.quantifier = input.quantifier })
+        end
+      end
+
+      class GroupCapturePositional < self
+        handle(::Regexp::Expression::Group::Capture)
+
+      private
+
+        def dispatch
+          emit_passive_group unless subexpressions.empty?
+        end
+      end
+
+      class GroupCaptureNamed < self
+        handle(::Regexp::Expression::Group::Named)
+
+      private
+
+        def dispatch
+          return if input.name.start_with?('_') || subexpressions.empty?
+
+          emit_passive_group
+
+          emit_expression(
+            klass: ::Regexp::Expression::Group::Named,
+            text:  "(?<_#{input.name}>"
+          )
+        end
+      end
+
+      class Recurse < self
+        ns = ::Regexp::Expression
+
+        # This list of nodes with subexessions is not yet complete.
+        handle(ns::Assertion::Base)
+        handle(ns::Assertion::Lookahead)
+        handle(ns::Assertion::Lookbehind)
+        handle(ns::Assertion::NegativeLookahead)
+        handle(ns::Assertion::NegativeLookbehind)
+        handle(ns::Alternative)
+        handle(ns::Alternation)
+        handle(ns::Sequence)
+        handle(ns::CharacterSet)
+        handle(ns::CharacterSet::Range)
+        handle(ns::Conditional::Branch)
+        handle(ns::Conditional::Expression)
+        handle(ns::Group::Absence)
+        handle(ns::Group::Atomic)
+        handle(ns::Group::Capture)
+        handle(ns::Group::Comment)
+        handle(ns::Group::Named)
+        handle(ns::Group::Options)
+        handle(ns::Group::Passive)
+        handle(ns::Root)
+
+      private
+
+        def dispatch
+          subexpressions.each_with_index do |expression, index|
+            self.class.mutate(expression).each do |new_expression|
+              emit(mk_dup.tap { |new| new.expressions[index] = new_expression })
+            end
+          end
+        end
+      end
+    end # Regexp
+  end # Mutator
+end # Mutant

data/lib/mutant/version.rb

@@ -2,5 +2,5 @@
 
 module Mutant
   # Current mutant version
-  VERSION = '0.11.17'
+  VERSION = '0.11.18'
 end # Mutant

data/lib/mutant.rb

@@ -84,15 +84,6 @@ module Mutant
     require 'mutant/ast/named_children'
     require 'mutant/ast/node_predicates'
     require 'mutant/ast/find_metaclass_containing'
-    require 'mutant/ast/regexp'
-    require 'mutant/ast/regexp/transformer'
-    require 'mutant/ast/regexp/transformer/direct'
-    require 'mutant/ast/regexp/transformer/named_group'
-    require 'mutant/ast/regexp/transformer/options_group'
-    require 'mutant/ast/regexp/transformer/quantifier'
-    require 'mutant/ast/regexp/transformer/recursive'
-    require 'mutant/ast/regexp/transformer/root'
-    require 'mutant/ast/regexp/transformer/text'
     require 'mutant/ast/meta'
     require 'mutant/ast/meta/send'
     require 'mutant/ast/meta/const'
@@ -123,15 +114,6 @@ module Mutant
     require 'mutant/mutator/util/symbol'
     require 'mutant/mutator/node'
     require 'mutant/mutator/node/generic'
-    require 'mutant/mutator/node/regexp'
-    require 'mutant/mutator/node/regexp/alternation_meta'
-    require 'mutant/mutator/node/regexp/beginning_of_line_anchor'
-    require 'mutant/mutator/node/regexp/capture_group'
-    require 'mutant/mutator/node/regexp/named_group'
-    require 'mutant/mutator/node/regexp/character_type'
-    require 'mutant/mutator/node/regexp/end_of_line_anchor'
-    require 'mutant/mutator/node/regexp/end_of_string_or_before_end_of_line_anchor'
-    require 'mutant/mutator/node/regexp/zero_or_more'
     require 'mutant/mutator/node/literal'
     require 'mutant/mutator/node/literal/boolean'
     require 'mutant/mutator/node/literal/range'
@@ -190,6 +172,7 @@ module Mutant
     require 'mutant/mutator/node/procarg_zero'
     require 'mutant/mutator/node/kwargs'
     require 'mutant/mutator/node/numblock'
+    require 'mutant/mutator/regexp'
     require 'mutant/loader'
     require 'mutant/context'
     require 'mutant/scope'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mutant
 version: !ruby/object:Gem::Version
-  version: 0.11.17
+  version: 0.11.18
 platform: ruby
 authors:
 - Markus Schirp
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-11-21 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
@@ -395,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