diff --git a/Changelog.md b/Changelog.md
index 1ceb829a..e930ef3c 100644
--- a/Changelog.md
+++ b/Changelog.md
@@ -1,3 +1,10 @@
+# v0.7.0 2024-09-16
+
+[#366](https://github.com/mbj/unparser/pull/366)
+
+* Fix all known dstring issues.
+* Interface changes.
+
 # v0.6.15 2024-06-10
 
 [#373](https://github.com/mbj/unparser/pull/373)
diff --git a/Gemfile b/Gemfile
index 7f4f5e95..e2e47a95 100644
--- a/Gemfile
+++ b/Gemfile
@@ -2,4 +2,6 @@
 
 source 'https://rubygems.org'
 
+gem 'mutant', path: '../mutant'
+
 gemspec
diff --git a/Gemfile.lock b/Gemfile.lock
index 2e6c9330..dbc77693 100644
--- a/Gemfile.lock
+++ b/Gemfile.lock
@@ -1,7 +1,17 @@
+PATH
+  remote: ../mutant
+  specs:
+    mutant (0.12.4)
+      diff-lcs (~> 1.3)
+      parser (~> 3.3.0)
+      regexp_parser (~> 2.9.0)
+      sorbet-runtime (~> 0.5.0)
+      unparser (~> 0.7.0)
+
 PATH
   remote: .
   specs:
-    unparser (0.6.15)
+    unparser (0.7.0)
       diff-lcs (~> 1.3)
       parser (>= 3.3.0)
 
@@ -10,67 +20,57 @@ GEM
   specs:
     ast (2.4.2)
     diff-lcs (1.5.1)
-    json (2.7.2)
+    json (2.7.5)
     language_server-protocol (3.17.0.3)
-    mutant (0.12.3)
-      diff-lcs (~> 1.3)
-      parser (~> 3.3.0)
-      regexp_parser (~> 2.9.0)
-      sorbet-runtime (~> 0.5.0)
-      unparser (~> 0.6.14)
-    mutant-rspec (0.12.3)
-      mutant (= 0.12.3)
+    mutant-rspec (0.12.4)
+      mutant (= 0.12.4)
       rspec-core (>= 3.8.0, < 4.0.0)
-    parallel (1.25.1)
-    parser (3.3.2.0)
+    parallel (1.26.3)
+    parser (3.3.5.0)
       ast (~> 2.4.1)
       racc
-    racc (1.8.0)
+    racc (1.8.1)
     rainbow (3.1.1)
     regexp_parser (2.9.2)
-    rexml (3.2.9)
-      strscan
     rspec (3.13.0)
       rspec-core (~> 3.13.0)
       rspec-expectations (~> 3.13.0)
       rspec-mocks (~> 3.13.0)
-    rspec-core (3.13.0)
+    rspec-core (3.13.2)
       rspec-support (~> 3.13.0)
-    rspec-expectations (3.13.0)
+    rspec-expectations (3.13.3)
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.13.0)
-    rspec-its (1.3.0)
+    rspec-its (1.3.1)
       rspec-core (>= 3.0.0)
       rspec-expectations (>= 3.0.0)
-    rspec-mocks (3.13.1)
+    rspec-mocks (3.13.2)
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.13.0)
     rspec-support (3.13.1)
-    rubocop (1.64.1)
+    rubocop (1.67.0)
       json (~> 2.3)
       language_server-protocol (>= 3.17.0)
       parallel (~> 1.10)
       parser (>= 3.3.0.2)
       rainbow (>= 2.2.2, < 4.0)
-      regexp_parser (>= 1.8, < 3.0)
-      rexml (>= 3.2.5, < 4.0)
-      rubocop-ast (>= 1.31.1, < 2.0)
+      regexp_parser (>= 2.4, < 3.0)
+      rubocop-ast (>= 1.32.2, < 2.0)
       ruby-progressbar (~> 1.7)
       unicode-display_width (>= 2.4.0, < 3.0)
-    rubocop-ast (1.31.3)
+    rubocop-ast (1.33.0)
       parser (>= 3.3.1.0)
     rubocop-packaging (0.5.2)
       rubocop (>= 1.33, < 2.0)
     ruby-progressbar (1.13.0)
-    sorbet-runtime (0.5.11422)
-    strscan (3.1.0)
-    unicode-display_width (2.5.0)
+    sorbet-runtime (0.5.11625)
+    unicode-display_width (2.6.0)
 
 PLATFORMS
-  ruby
+  x86_64-linux
 
 DEPENDENCIES
-  mutant (~> 0.12.2)
+  mutant!
   mutant-rspec (~> 0.12.2)
   rspec (~> 3.9)
   rspec-core (~> 3.9)
diff --git a/bin/corpus b/bin/corpus
index 00b55c03..ae953f85 100755
--- a/bin/corpus
+++ b/bin/corpus
@@ -1,10 +1,14 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
 
+require 'etc'
 require 'mutant'
 require 'optparse'
+require 'pathname'
 require 'unparser'
 
+Thread.abort_on_exception = true
+
 module Unparser
   module Corpus
     ROOT = Pathname.new(__dir__).parent
@@ -17,16 +21,85 @@ module Unparser
       #
       # @return [Boolean]
       def verify
+        puts("Verifiying: #{name}")
         checkout
-        command = %W[unparser #{repo_path}]
-        exclude.each do |name|
-          command.push('--ignore', repo_path.join(name).to_s)
+
+        paths = Pathname.glob(Pathname.new(repo_path).join('**/*.rb'))
+
+        driver = Mutant::Parallel.async(
+          config: Mutant::Parallel::Config.new(
+            block:            method(:verify_path),
+            jobs:             Etc.nprocessors,
+            on_process_start: ->(*) {},
+            process_name:     'unparser-corpus-test',
+            sink:             Sink.new,
+            source:           Mutant::Parallel::Source::Array.new(jobs: paths),
+            thread_name:      'unparser-corpus-test',
+            timeout:          nil
+          ),
+          world:  Mutant::WORLD
+        )
+
+        loop do
+          status = driver.wait_timeout(1)
+
+          puts("Processed: #{status.payload.total}")
+
+          status.payload.errors.each do |report|
+            puts report
+            fail
+          end
+
+          break if status.done?
         end
-        Kernel.system(*command)
+
+        true
       end
 
     private
 
+      class Sink
+        include Mutant::Parallel::Sink
+
+        attr_reader :errors, :total
+
+        def initialize
+          @errors = []
+          @total  = 0
+        end
+
+        def stop?
+          !@errors.empty?
+        end
+
+        def status
+          self
+        end
+
+        def response(response)
+          if response.error
+            Mutant::WORLD.stderr.puts(response.log)
+            fail response.error
+          end
+
+          @total += 1
+
+          if response.result
+            @errors << response.result
+          end
+        end
+      end
+
+      def verify_path(path)
+        validation = Validation.from_path(path)
+
+        if original_syntax_error?(validation) || generated_encoding_error?(validation) || validation.success?
+          return
+        end
+
+        validation.report
+      end
+
       def checkout
         TMP.mkdir unless TMP.directory?
 
@@ -50,6 +123,21 @@ module Unparser
         TMP.join(name)
       end
 
+    private
+
+      # This happens if the original source contained a non UTF charset meta comment.
+      # These are not exposed to the AST in a way unparser could know about to generate a non UTF-8
+      # target and emit that meta comment itself.
+      # For the purpose of corpus testing these cases are ignored.
+      def generated_encoding_error?(validation)
+        exception = validation.generated_node.from_left { return false }
+        exception.instance_of?(Parser::SyntaxError) && exception.message.eql?('literal contains escape sequences incompatible with UTF-8')
+      end
+
+      def original_syntax_error?(validation)
+        validation.original_node.from_left { return false }.instance_of?(Parser::SyntaxError)
+      end
+
       def system(arguments)
         return if Kernel.system(*arguments)
 
diff --git a/bin/parser-round-trip-test b/bin/parser-round-trip-test
index e9860bd2..a87cf1b6 100755
--- a/bin/parser-round-trip-test
+++ b/bin/parser-round-trip-test
@@ -40,7 +40,14 @@ class Test
     :rubies
   )
 
-  EXPECT_FAILURE = {}.freeze
+  EXPECT_FAILURE         = {}.freeze
+  STATIC_LOCAL_VARIABLES = %w[foo bar baz].to_set.freeze
+
+  NO_ROUND_TRIP = %i[
+    test_int___LINE__
+    test_pattern_matching__FILE__LINE_literals
+    test_string___FILE__
+  ].freeze
 
   def legacy_attributes
     default_builder_attributes.reject do |attribute_name, value|
@@ -56,6 +63,8 @@ class Test
       "Non targeted rubies: #{rubies.join(',')}"
     elsif validation.original_node.left?
       'Test specifies a syntax error'
+    elsif NO_ROUND_TRIP.include?(name)
+      'Test not round trippable'
     end
   end
 
@@ -77,20 +86,25 @@ class Test
 
   # rubocop:disable Metrics/AbcSize
   def validation
-    identification   = name.to_s
+    identification = name.to_s
+
+    ast = Unparser::AST.new(
+      comments:               [],
+      explicit_encoding:      nil,
+      node:                   node,
+      static_local_variables: STATIC_LOCAL_VARIABLES
+    )
 
-    generated_source = Unparser.unparse_either(node)
+    generated_source = Unparser.unparse_ast_either(ast)
       .fmap { |string| string.dup.force_encoding(parser_source.encoding).freeze }
 
-    generated_node = generated_source.bind do |source|
-      parse_either(source, identification)
-    end
+    generated_node = generated_source.bind { |source| parse_either(source, identification) }
 
     Unparser::Validation.new(
       generated_node:   generated_node,
       generated_source: generated_source,
       identification:   identification,
-      original_node:    parse_either(parser_source, identification).fmap { node },
+      original_ast:     parse_either_ast(parser_source, identification),
       original_source:  right(parser_source)
     )
   end
@@ -99,7 +113,7 @@ class Test
 
   def parser
     Unparser.parser.tap do |parser|
-      %w[foo bar baz].each(&parser.static_env.method(:declare))
+      STATIC_LOCAL_VARIABLES.each(&parser.static_env.method(:declare))
     end
   end
 
@@ -108,6 +122,17 @@ class Test
       parser.parse(Unparser.buffer(source, identification))
     end
   end
+
+  def parse_either_ast(source, identification)
+    parse_either(source, identification).fmap do |node|
+      Unparser::AST.new(
+        comments:               [],
+        explicit_encoding:      nil,
+        node:                   node,
+        static_local_variables: Set.new
+      )
+    end
+  end
 end
 
 class Execution
diff --git a/lib/unparser.rb b/lib/unparser.rb
index 0938a81a..aaa59dc8 100644
--- a/lib/unparser.rb
+++ b/lib/unparser.rb
@@ -44,57 +44,114 @@ def initialize(message, node)
       @node = node
       freeze
     end
-  end
+  end # InvalidNodeError
+
+  # Error raised when unparser encounders AST it cannot generate source for that would parse to the same AST.
+  class UnsupportedNodeError < RuntimeError
+  end # UnsupportedNodeError
 
   # Unparse an AST (and, optionally, comments) into a string
   #
   # @param [Parser::AST::Node, nil] node
-  # @param [Array] comment_array
+  # @param [Array] comments
+  # @param [Encoding, nil] explicit_encoding
+  # @param [Set<Symbol>] static_local_variables
+  #
+  # @return [String]
+  #
+  # @raise InvalidNodeError
+  #   if the node passed is invalid
+  #
+  # @api public
+  #
+  # mutant:disable
+  def self.unparse(
+    node,
+    comments:               EMPTY_ARRAY,
+    explicit_encoding:      nil,
+    static_local_variables: Set.new
+  )
+    unparse_ast(
+      AST.new(
+        comments:               comments,
+        explicit_encoding:      explicit_encoding,
+        node:                   node,
+        static_local_variables: static_local_variables
+      )
+    )
+  end
+
+  # Unparse an AST
+  #
+  # @param [AST] ast
   #
   # @return [String]
   #
   # @raise InvalidNodeError
   #   if the node passed is invalid
   #
+  # @raise UnsupportedNodeError
+  #   if the node passed is valid but unparser cannot unparse it
+  #
   # @api public
-  def self.unparse(node, comment_array = [])
-    return '' if node.nil?
+  def self.unparse_ast(ast)
+    return EMPTY_STRING if ast.node.nil?
+
+    local_variable_scope = AST::LocalVariableScope.new(
+      node:                   ast.node,
+      static_local_variables: ast.static_local_variables
+    )
 
     Buffer.new.tap do |buffer|
       Emitter::Root.new(
-        buffer,
-        node,
-        Comments.new(comment_array)
+        buffer:               buffer,
+        comments:             Comments.new(ast.comments),
+        explicit_encoding:    ast.explicit_encoding,
+        local_variable_scope: local_variable_scope,
+        node:                 ast.node
       ).write_to_buffer
     end.content
   end
 
-  # Unparse with validation
+  # Unparse AST either
   #
-  # @param [Parser::AST::Node, nil] node
-  # @param [Array] comment_array
+  # @param [AST] ast
   #
-  # @return [Either<Validation,String>]
-  def self.unparse_validate(node, comment_array = [])
-    generated = unparse(node, comment_array)
-    validation = Validation.from_string(generated)
+  # @return [Either<Exception,String>]
+  def self.unparse_ast_either(ast)
+    Either.wrap_error(Exception) { unparse_ast(ast) }
+  end
+
+  # Unparse AST either
+  #
+  # @param [AST] ast
+  #
+  # @return [Either<Exception,String>]
+  def self.unparse_validate_ast_either(ast:)
+    validation = Validation.from_ast(ast:)
 
     if validation.success?
-      Either::Right.new(generated)
+      Either::Right.new(validation.generated_source.from_right)
     else
       Either::Left.new(validation)
     end
   end
 
-  # Unparse capturing errors
-  #
-  # This is mostly useful for writing testing tools against unparser.
+  # Unparse with validation
   #
   # @param [Parser::AST::Node, nil] node
+  # @param [Array] comments
   #
-  # @return [Either<Exception, String>]
-  def self.unparse_either(node)
-    Either.wrap_error(Exception) { unparse(node) }
+  # @return [Either<Validation,String>]
+  def self.unparse_validate(node, comments: EMPTY_ARRAY)
+    generated = unparse(node, comments:)
+    validation = Validation.from_string(generated)
+
+    if validation.success?
+      Either::Right.new(generated)
+    else
+      Either::Left.new(validation)
+    end
   end
 
   # Parse string into AST
@@ -103,27 +160,37 @@ def self.unparse_either(node)
   #
   # @return [Parser::AST::Node, nil]
   def self.parse(source)
-    parser.parse(buffer(source))
+    parse_ast(source).node
   end
 
   # Parse string into either syntax error or AST
   #
   # @param [String] source
   #
-  # @return [Either<Parser::SyntaxError, (Parser::ASTNode, nil)>]
-  def self.parse_either(source)
-    Either.wrap_error(Parser::SyntaxError) do
-      parser.parse(buffer(source))
+  # @return [Either<Exception, (Parser::ASTNode, nil)>]
+  def self.parse_ast_either(source)
+    Either.wrap_error(Exception) do
+      parse_ast(source)
     end
   end
 
-  # Parse string into AST, with comments
+  # Parse source with ast details
   #
   # @param [String] source
   #
-  # @return [Parser::AST::Node]
-  def self.parse_with_comments(source)
-    parser.parse_with_comments(buffer(source))
+  # @return [AST]
+  #
+  # mutant:disable
+  def self.parse_ast(source, static_local_variables: Set.new)
+    explicit_encoding = Parser::Source::Buffer.recognize_encoding(source.dup.force_encoding(Encoding::BINARY))
+    node, comments = parser.parse_with_comments(buffer(source))
+
+    AST.new(
+      comments:               comments,
+      explicit_encoding:      explicit_encoding,
+      node:                   node,
+      static_local_variables: static_local_variables
+    )
   end
 
   # Parser instance that produces AST unparser understands
@@ -210,6 +277,7 @@ def self.buffer(source, identification = '(string)')
 require 'unparser/emitter/root'
 require 'unparser/emitter/send'
 require 'unparser/emitter/simple'
+require 'unparser/emitter/string'
 require 'unparser/emitter/splat'
 require 'unparser/emitter/super'
 require 'unparser/emitter/undef'
@@ -224,6 +292,7 @@ def self.buffer(source, identification = '(string)')
 require 'unparser/writer'
 require 'unparser/writer/binary'
 require 'unparser/writer/dynamic_string'
+require 'unparser/writer/regexp'
 require 'unparser/writer/resbody'
 require 'unparser/writer/rescue'
 require 'unparser/writer/send'
diff --git a/lib/unparser/anima.rb b/lib/unparser/anima.rb
index 8618c9fd..fea38e0c 100644
--- a/lib/unparser/anima.rb
+++ b/lib/unparser/anima.rb
@@ -137,11 +137,20 @@ def with(attributes)
     def included(descendant)
       descendant.instance_exec(self, attribute_names) do |anima, names|
         # Define anima method
+
+        class << self
+          undef_method(:anima) if method_defined?(:anima)
+        end
+
         define_singleton_method(:anima) { anima }
 
         # Define instance methods
         include InstanceMethods
 
+        names.each do |name|
+          undef_method(name) if method_defined?(name)
+        end
+
         # Define attribute readers
         attr_reader(*names)
 
diff --git a/lib/unparser/ast.rb b/lib/unparser/ast.rb
index 976cd9b3..2fb08138 100644
--- a/lib/unparser/ast.rb
+++ b/lib/unparser/ast.rb
@@ -2,7 +2,9 @@
 
 module Unparser
   # Namespace for AST processing tools
-  module AST
+  class AST
+    include Anima.new(:comments, :explicit_encoding, :node, :static_local_variables)
+
     FIRST_CHILD = ->(node) { node.children.first }.freeze
     TAUTOLOGY   = ->(_node) { true }.freeze
 
@@ -16,12 +18,21 @@ module AST
         arg
         kwarg
         kwoptarg
+        kwrestarg
         lvasgn
         optarg
-        procarg0
         restarg
       ].to_set.freeze
 
+    def self.from_node(node:)
+      new(
+        comments:               EMPTY_ARRAY,
+        explicit_encoding:      nil,
+        node:,
+        static_local_variables: Set.new
+      )
+    end
+
     # Test for local variable inherited scope reset
     #
     # @param [Parser::AST::Node] node
diff --git a/lib/unparser/ast/local_variable_scope.rb b/lib/unparser/ast/local_variable_scope.rb
index fc081d02..a2e3d6e8 100644
--- a/lib/unparser/ast/local_variable_scope.rb
+++ b/lib/unparser/ast/local_variable_scope.rb
@@ -1,11 +1,10 @@
 # frozen_string_literal: true
 
 module Unparser
-  module AST
-
+  class AST
     # Calculated local variable scope for a given node
     class LocalVariableScope
-      include Enumerable, Adamantium
+      include Adamantium, Anima.new(:static_local_variables, :node)
 
       # Initialize object
       #
@@ -15,11 +14,17 @@ class LocalVariableScope
       #
       # @api private
       #
-      def initialize(node)
+      # mutant:disable
+      def initialize(*)
+        super(*)
+
         items = []
-        LocalVariableScopeEnumerator.each(node) do |*scope|
-          items << scope
-        end
+
+        LocalVariableScopeEnumerator.each(
+          node:  node,
+          stack: static_local_variables.dup
+        ) { |*scope| items << scope }
+
         @items = items
       end
 
@@ -53,6 +58,15 @@ def local_variable_defined_for_node?(node, name)
         end
       end
 
+      # mutant:disable
+      def local_variables_for_node(needle)
+        @items.each do |node, current|
+          return current if node.equal?(needle)
+        end
+
+        return Set.new
+      end
+
       # Test if local variables where first assigned in body and read by conditional
       #
       # @param [Parser::AST::Node] body
@@ -90,21 +104,13 @@ class LocalVariableScopeEnumerator
       #
       # @api private
       #
-      def initialize
-        @stack = [Set.new]
+      def initialize(stack:)
+        @stack = [stack]
       end
 
       # Enumerate each node with its local variable scope
-      #
-      # @param [Parser::AST::Node] node
-      #
-      # @return [self]
-      #
-      # @api private
-      #
-      def self.each(node, &block)
-        new.each(node, &block)
-        self
+      def self.each(node:, stack:, &block)
+        new(stack: stack).each(node: node, &block)
       end
 
       # Enumerate local variable scope scope
@@ -117,7 +123,7 @@ def self.each(node, &block)
       #
       # @api private
       #
-      def each(node, &block)
+      def each(node:, &block)
         visit(node, &block)
       end
 
@@ -132,7 +138,7 @@ def visit(node, &block)
         enter(node)
         yield node, current.dup, before
         node.children.each do |child|
-          visit(child, &block) if child.is_a?(Parser::AST::Node)
+          visit(child, &block) if child.instance_of?(Parser::AST::Node)
         end
         leave(node)
       end
@@ -142,7 +148,7 @@ def enter(node)
         when *RESET_NODES
           push_reset
         when ASSIGN_NODES
-          define(node.children.first)
+          value = node.children.first and define(value)
         when *INHERIT_NODES
           push_inherit
         end
diff --git a/lib/unparser/buffer.rb b/lib/unparser/buffer.rb
index ebb4dcaa..6cf68a35 100644
--- a/lib/unparser/buffer.rb
+++ b/lib/unparser/buffer.rb
@@ -117,6 +117,10 @@ def write(fragment)
       self
     end
 
+    def write_encoding(encoding)
+      write("# -*- encoding: #{encoding.name} -*-\n")
+    end
+
   private
 
     INDENT_SPACE = '  '.freeze
diff --git a/lib/unparser/cli.rb b/lib/unparser/cli.rb
index 1768e6f0..d5a1601c 100644
--- a/lib/unparser/cli.rb
+++ b/lib/unparser/cli.rb
@@ -75,11 +75,12 @@ def initialize(arguments)
       @ignore  = Set.new
       @targets = []
 
-      @fail_fast  = false
-      @start_with = nil
-      @success    = true
-      @validation = :validation
-      @verbose    = false
+      @fail_fast                    = false
+      @start_with                   = nil
+      @success                      = true
+      @validation                   = :validation
+      @verbose                      = false
+      @ignore_original_syntax_error = false
 
       opts = OptionParser.new do |builder|
         add_options(builder)
@@ -114,6 +115,9 @@ def add_options(builder)
       builder.on('-l', '--literal') do
         @validation = :literal_validation
       end
+      builder.on('--ignore-original-syntax-error') do
+        @ignore_original_syntax_error = true
+      end
       builder.on('--ignore FILE') do |file|
         @ignore.merge(targets(file))
       end
@@ -145,6 +149,9 @@ def process_target(target)
       if validation.success?
         puts validation.report if @verbose
         puts "Success: #{validation.identification}"
+      elsif ignore_original_syntax_error?(validation)
+        exception = validation.original_node.from_left
+        puts "#{exception.class}: #{validation.identification} #{exception}"
       else
         puts validation.report
         puts "Error: #{validation.identification}"
@@ -152,6 +159,10 @@ def process_target(target)
       end
     end
 
+    def ignore_original_syntax_error?(validation)
+      @ignore_original_syntax_error && validation.original_node.from_left { nil }.instance_of?(Parser::SyntaxError)
+    end
+
     def effective_targets
       if @start_with
         reject = true
diff --git a/lib/unparser/emitter.rb b/lib/unparser/emitter.rb
index aedc5171..bc77c975 100644
--- a/lib/unparser/emitter.rb
+++ b/lib/unparser/emitter.rb
@@ -6,7 +6,7 @@ module Unparser
   # Emitter base class
   class Emitter
     include Adamantium, AbstractType, Constants, Generation, NodeHelpers
-    include Anima.new(:buffer, :comments, :node, :local_variable_scope)
+    include Anima.new(:buffer, :comments, :explicit_encoding, :local_variable_scope, :node)
 
     public :node
 
@@ -25,7 +25,7 @@ module LocalVariableRoot
       # @api private
       #
       def local_variable_scope
-        AST::LocalVariableScope.new(node)
+        AST::LocalVariableScope.new(node: node, static_local_variables: Set.new)
       end
 
       def self.included(descendant)
@@ -67,7 +67,7 @@ def emit_mlhs
     # @api private
     #
     # rubocop:disable Metrics/ParameterLists
-    def self.emitter(buffer:, comments:, node:, local_variable_scope:)
+    def self.emitter(buffer:, explicit_encoding:, comments:, node:, local_variable_scope:)
       type = node.type
 
       klass = REGISTRY.fetch(type) do
@@ -75,10 +75,11 @@ def self.emitter(buffer:, comments:, node:, local_variable_scope:)
       end
 
       klass.new(
-        buffer:               buffer,
-        comments:             comments,
-        local_variable_scope: local_variable_scope,
-        node:                 node
+        buffer:,
+        comments:,
+        explicit_encoding:,
+        local_variable_scope:,
+        node:
       )
     end
     # rubocop:enable Metrics/ParameterLists
@@ -91,5 +92,11 @@ def self.emitter(buffer:, comments:, node:, local_variable_scope:)
     #
     abstract_method :dispatch
 
+  private
+
+    def emitter(node)
+      Emitter.emitter(**to_h.merge(node: node))
+    end
+
   end # Emitter
 end # Unparser
diff --git a/lib/unparser/emitter/array_pattern.rb b/lib/unparser/emitter/array_pattern.rb
index ae1833de..23316848 100644
--- a/lib/unparser/emitter/array_pattern.rb
+++ b/lib/unparser/emitter/array_pattern.rb
@@ -19,7 +19,7 @@ def dispatch
 
       def emit_member(node)
         if n_match_rest?(node)
-          writer_with(MatchRest, node).emit_array_pattern
+          writer_with(MatchRest, node:).emit_array_pattern
         else
           visit(node)
         end
diff --git a/lib/unparser/emitter/assignment.rb b/lib/unparser/emitter/assignment.rb
index 134b90e0..6f20c514 100644
--- a/lib/unparser/emitter/assignment.rb
+++ b/lib/unparser/emitter/assignment.rb
@@ -12,9 +12,7 @@ def symbol_name
       end
 
       def emit_heredoc_remainders
-        return unless right
-
-        emitter(right).emit_heredoc_remainders
+        right_emitter.emit_heredoc_remainders if right
       end
 
     private
@@ -30,12 +28,17 @@ def emit_right
         write(' = ')
 
         if BINARY_OPERATOR.include?(right.type)
-          writer_with(Writer::Binary, right).emit_operator
+          writer_with(Writer::Binary, node: right).emit_operator
         else
-          visit(right)
+          right_emitter.write_to_buffer
         end
       end
 
+      def right_emitter
+        emitter(right)
+      end
+      memoize :right_emitter
+
       abstract_method :emit_left
 
       # Variable assignment emitter
diff --git a/lib/unparser/emitter/binary.rb b/lib/unparser/emitter/binary.rb
index 8ad482e5..27345c6b 100644
--- a/lib/unparser/emitter/binary.rb
+++ b/lib/unparser/emitter/binary.rb
@@ -13,7 +13,7 @@ def dispatch
       end
 
       def writer
-        writer_with(Writer::Binary, node)
+        writer_with(Writer::Binary, node:)
       end
       memoize :writer
     end # Binary
diff --git a/lib/unparser/emitter/block.rb b/lib/unparser/emitter/block.rb
index f400e0b6..0ddfd503 100644
--- a/lib/unparser/emitter/block.rb
+++ b/lib/unparser/emitter/block.rb
@@ -42,7 +42,7 @@ def write_close
       end
 
       def target_writer
-        writer_with(Writer::Send::Regular, target)
+        writer_with(Writer::Send::Regular, node: target)
       end
       memoize :target_writer
 
@@ -65,7 +65,7 @@ def emit_send_target
       end
 
       def emit_lambda_arguments
-        parentheses { writer_with(Args, arguments).emit_lambda_arguments }
+        parentheses { writer_with(Args, node: arguments).emit_lambda_arguments }
       end
 
       def numblock?
@@ -78,7 +78,7 @@ def emit_block_arguments
         ws
 
         parentheses('|', '|') do
-          writer_with(Args, arguments).emit_block_arguments
+          writer_with(Args, node: arguments).emit_block_arguments
         end
       end
 
diff --git a/lib/unparser/emitter/def.rb b/lib/unparser/emitter/def.rb
index 7d75ee1c..284ad884 100644
--- a/lib/unparser/emitter/def.rb
+++ b/lib/unparser/emitter/def.rb
@@ -26,7 +26,7 @@ def emit_arguments
         return if arguments.children.empty?
 
         parentheses do
-          writer_with(Args, arguments).emit_def_arguments
+          writer_with(Args, node: arguments).emit_def_arguments
         end
       end
 
diff --git a/lib/unparser/emitter/dstr.rb b/lib/unparser/emitter/dstr.rb
index b0a0f88c..f3350c9f 100644
--- a/lib/unparser/emitter/dstr.rb
+++ b/lib/unparser/emitter/dstr.rb
@@ -8,15 +8,20 @@ class DStr < self
       handle :dstr
 
       def emit_heredoc_remainders
-        writer_with(Writer::DynamicString, node).emit_heredoc_reminder
+        dstr_writer.emit_heredoc_remainder
       end
 
     private
 
       def dispatch
-        writer_with(Writer::DynamicString, node).dispatch
+        dstr_writer.dispatch
       end
 
+      def dstr_writer
+        writer_with(Writer::DynamicString, node:)
+      end
+      memoize :dstr_writer
+
     end # DStr
   end # Emitter
 end # Unparser
diff --git a/lib/unparser/emitter/for.rb b/lib/unparser/emitter/for.rb
index 5532eb57..12d34e44 100644
--- a/lib/unparser/emitter/for.rb
+++ b/lib/unparser/emitter/for.rb
@@ -18,7 +18,7 @@ def dispatch
       end
 
       def emit_condition
-        visit(condition)
+        emitter(condition).emit_mlhs
         write(' in ')
         visit(assignment)
         write(' do')
diff --git a/lib/unparser/emitter/hash.rb b/lib/unparser/emitter/hash.rb
index 70bf9c2b..9e13dd05 100644
--- a/lib/unparser/emitter/hash.rb
+++ b/lib/unparser/emitter/hash.rb
@@ -7,7 +7,7 @@ class Hash < self
       handle :hash
 
       def emit_heredoc_remainders
-        children.each(&method(:emit_heredoc_reminder_member))
+        children.each(&method(:emit_heredoc_remainder_member))
       end
 
     private
@@ -24,7 +24,7 @@ def dispatch
         end
       end
 
-      def emit_heredoc_reminder_member(node)
+      def emit_heredoc_remainder_member(node)
         emitter(node.children.last).emit_heredoc_remainders if n_pair?(node)
       end
 
diff --git a/lib/unparser/emitter/hash_pattern.rb b/lib/unparser/emitter/hash_pattern.rb
index c03fa91d..614aa782 100644
--- a/lib/unparser/emitter/hash_pattern.rb
+++ b/lib/unparser/emitter/hash_pattern.rb
@@ -32,7 +32,7 @@ def emit_member(node)
         when :match_var
           emit_match_var(node)
         when :match_rest
-          writer_with(MatchRest, node).emit_hash_pattern
+          writer_with(MatchRest, node:).emit_hash_pattern
         else
           visit(node)
         end
diff --git a/lib/unparser/emitter/index.rb b/lib/unparser/emitter/index.rb
index 7f11f60f..e4b3e976 100644
--- a/lib/unparser/emitter/index.rb
+++ b/lib/unparser/emitter/index.rb
@@ -5,6 +5,10 @@ class Emitter
     # Emitter for send to index references
     class Index < self
 
+      def emit_heredoc_remainders
+        emitter(children.last).emit_heredoc_remainders
+      end
+
     private
 
       def dispatch
@@ -40,10 +44,6 @@ class Assign < self
 
         private_constant(*constants(false))
 
-        def emit_heredoc_remainders
-          emitter(children.last).emit_heredoc_remainders
-        end
-
         def dispatch
           emit_receiver
           emit_operation(children[VALUE_RANGE])
diff --git a/lib/unparser/emitter/kwargs.rb b/lib/unparser/emitter/kwargs.rb
index bffffc93..9456e803 100644
--- a/lib/unparser/emitter/kwargs.rb
+++ b/lib/unparser/emitter/kwargs.rb
@@ -5,6 +5,12 @@ class Emitter
     class Kwargs < self
       handle :kwargs
 
+      def emit_heredoc_remainders
+        children.each do |child|
+          emitter(child).emit_heredoc_remainders
+        end
+      end
+
       def dispatch
         delimited(children)
       end
diff --git a/lib/unparser/emitter/pair.rb b/lib/unparser/emitter/pair.rb
index 8f73bea1..4a3d17aa 100644
--- a/lib/unparser/emitter/pair.rb
+++ b/lib/unparser/emitter/pair.rb
@@ -12,6 +12,10 @@ class Pair < self
 
       children :key, :value
 
+      def emit_heredoc_remainders
+        emitter(value).emit_heredoc_remainders
+      end
+
     private
 
       def dispatch
diff --git a/lib/unparser/emitter/primitive.rb b/lib/unparser/emitter/primitive.rb
index ec17b16b..0bc0bcbf 100644
--- a/lib/unparser/emitter/primitive.rb
+++ b/lib/unparser/emitter/primitive.rb
@@ -7,19 +7,6 @@ class Primitive < self
 
       children :value
 
-      # Emitter for primitives based on Object#inspect
-      class Inspect < self
-
-        handle :str
-
-      private
-
-        def dispatch
-          write(value.inspect)
-        end
-
-      end # Inspect
-
       class Symbol < self
 
         handle :sym
diff --git a/lib/unparser/emitter/regexp.rb b/lib/unparser/emitter/regexp.rb
index a9bdc94e..5d20264a 100644
--- a/lib/unparser/emitter/regexp.rb
+++ b/lib/unparser/emitter/regexp.rb
@@ -4,32 +4,24 @@ module Unparser
   class Emitter
     # Emitter for regexp literals
     class Regexp < self
+
       handle :regexp
 
-      define_group(:body, 0..-2)
+      def emit_heredoc_remainders
+        writer.emit_heredoc_remainders
+      end
 
     private
 
       def dispatch
-        parentheses('/', '/') do
-          body.each(&method(:emit_body))
-        end
-        emit_options
+        writer.dispatch
       end
 
-      def emit_options
-        write(children.last.children.join)
+      def writer
+        writer_with(Writer::Regexp, node:)
       end
+      memoize :writer
 
-      def emit_body(node)
-        if n_begin?(node)
-          write('#{')
-          node.children.each(&method(:visit))
-          write('}')
-        else
-          buffer.append_without_prefix(node.children.first.gsub('/', '\/'))
-        end
-      end
     end # Regexp
   end # Emitter
 end # Unparser
diff --git a/lib/unparser/emitter/rescue.rb b/lib/unparser/emitter/rescue.rb
index e4ca0e32..b8a331fd 100644
--- a/lib/unparser/emitter/rescue.rb
+++ b/lib/unparser/emitter/rescue.rb
@@ -9,7 +9,13 @@ class Rescue < self
     private
 
       def dispatch
-        emit_rescue_postcontrol(node)
+        resbody = node.children.fetch(1)
+
+        if resbody.children[1]
+          emit_rescue_regular(node)
+        else
+          emit_rescue_postcontrol(node)
+        end
       end
     end # Rescue
   end # Emitter
diff --git a/lib/unparser/emitter/root.rb b/lib/unparser/emitter/root.rb
index e335f446..c950f45a 100644
--- a/lib/unparser/emitter/root.rb
+++ b/lib/unparser/emitter/root.rb
@@ -2,11 +2,7 @@
 
 module Unparser
   class Emitter
-    # Root emitter a special case
     class Root < self
-      include Concord::Public.new(:buffer, :node, :comments)
-      include LocalVariableRoot
-
       END_NL = %i[class sclass module begin].freeze
 
       private_constant(*constants(false))
diff --git a/lib/unparser/emitter/send.rb b/lib/unparser/emitter/send.rb
index 093d1587..1827dd81 100644
--- a/lib/unparser/emitter/send.rb
+++ b/lib/unparser/emitter/send.rb
@@ -21,7 +21,7 @@ def dispatch
       end
 
       def writer
-        writer_with(Writer::Send, node)
+        writer_with(Writer::Send, node:)
       end
       memoize :writer
     end # Send
diff --git a/lib/unparser/emitter/string.rb b/lib/unparser/emitter/string.rb
new file mode 100644
index 00000000..fabb213e
--- /dev/null
+++ b/lib/unparser/emitter/string.rb
@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Unparser
+  class Emitter
+    # Base class for primitive emitters
+    class String < self
+      children :value
+
+      handle :str
+
+    private
+
+      def dispatch
+        if explicit_encoding && !value_encoding.equal?(explicit_encoding)
+          if value_encoding.equal?(Encoding::UTF_8)
+            write_utf8_escaped
+          else
+            write_reencoded
+          end
+        else
+          write(value.inspect)
+        end
+      end
+
+      def write_reencoded
+        write('"')
+        value.encode(explicit_encoding).bytes.each do |byte|
+          write(byte.chr)
+        end
+        write('"')
+      end
+
+      def write_utf8_escaped
+        write('"')
+        value.each_codepoint do |codepoint|
+          write("\\u{#{codepoint.to_s(16)}}")
+        end
+        write('"')
+      end
+
+      def value_encoding
+        value.encoding
+      end
+
+    end # String
+  end # Emitter
+end # Unparser
diff --git a/lib/unparser/generation.rb b/lib/unparser/generation.rb
index 457607b2..568edbbc 100644
--- a/lib/unparser/generation.rb
+++ b/lib/unparser/generation.rb
@@ -208,21 +208,17 @@ def emit_body_ensure_rescue(node)
     end
 
     def emit_rescue_postcontrol(node)
-      writer = writer_with(Writer::Rescue, node)
+      writer = writer_with(Writer::Rescue, node:)
       writer.emit_postcontrol
       writer.emit_heredoc_remainders
     end
 
     def emit_rescue_regular(node)
-      writer_with(Writer::Rescue, node).emit_regular
+      writer_with(Writer::Rescue, node:).emit_regular
     end
 
-    def writer_with(klass, node)
-      klass.new(to_h.merge(node: node))
-    end
-
-    def emitter(node)
-      Emitter.emitter(**to_h.merge(node: node))
+    def writer_with(klass, node:, **attributes)
+      klass.new(to_h.merge(node: node, **attributes))
     end
 
     def visit(node)
diff --git a/lib/unparser/validation.rb b/lib/unparser/validation.rb
index b6600797..592ed91e 100644
--- a/lib/unparser/validation.rb
+++ b/lib/unparser/validation.rb
@@ -7,10 +7,14 @@ class Validation
       :generated_node,
       :generated_source,
       :identification,
-      :original_node,
+      :original_ast,
       :original_source
     )
 
+    class PhaseException
+      include Anima.new(:exception, :phase)
+    end
+
     # Test if source could be unparsed successfully
     #
     # @return [Boolean]
@@ -21,7 +25,7 @@ class Validation
     def success?
       [
         original_source,
-        original_node,
+        original_ast,
         generated_source,
         generated_node
       ].all?(&:right?) && generated_node.from_right.==(original_node.from_right)
@@ -47,48 +51,53 @@ def report
     end
     memoize :report
 
+    def original_node
+      original_ast.fmap(&:node)
+    end
+
     # Create validator from string
     #
     # @param [String] original_source
     #
     # @return [Validator]
     def self.from_string(original_source)
-      original_node = Unparser
-        .parse_either(original_source)
+      original_ast = parse_ast_either(original_source)
 
-      generated_source = original_node
+      generated_source = original_ast
         .lmap(&method(:const_unit))
-        .bind(&Unparser.method(:unparse_either))
+        .bind(&method(:unparse_ast_either))
 
       generated_node = generated_source
         .lmap(&method(:const_unit))
-        .bind(&Unparser.method(:parse_either))
+        .bind(&method(:parse_ast_either))
+        .fmap(&:node)
 
       new(
-        identification:   '(string)',
-        original_source:  Either::Right.new(original_source),
-        original_node:    original_node,
+        generated_node:   generated_node,
         generated_source: generated_source,
-        generated_node:   generated_node
+        identification:   '(string)',
+        original_ast:     original_ast,
+        original_source:  Either::Right.new(original_source)
       )
     end
 
-    # Create validator from node
+    # Create validator from ast
     #
-    # @param [Parser::AST::Node] original_node
+    # @param [Unparser::AST] ast
     #
     # @return [Validator]
-    def self.from_node(original_node)
-      generated_source = Unparser.unparse_either(original_node)
+    def self.from_ast(ast:)
+      generated_source = Unparser.unparse_ast_either(ast)
 
       generated_node = generated_source
         .lmap(&method(:const_unit))
-        .bind(&Unparser.public_method(:parse_either))
+        .bind(&method(:parse_ast_either))
+        .fmap(&:node)
 
       new(
         identification:   '(string)',
         original_source:  generated_source,
-        original_node:    Either::Right.new(original_node),
+        original_ast:     Either::Right.new(ast),
         generated_source: generated_source,
         generated_node:   generated_node
       )
@@ -100,20 +109,33 @@ def self.from_node(original_node)
     #
     # @return [Validator]
     def self.from_path(path)
-      from_string(path.read).with(identification: path.to_s)
+      from_string(path.read.freeze).with(identification: path.to_s)
+    end
+
+    def self.unparse_ast_either(ast)
+      Unparser.unparse_ast_either(ast)
     end
+    private_class_method :unparse_ast_either
+
+    def self.parse_ast_either(source)
+      Unparser.parse_ast_either(source)
+    end
+    private_class_method :parse_ast_either
+
+    def self.const_unit(_); end
+    private_class_method :const_unit
 
   private
 
     def make_report(label, attribute_name)
-      ["#{label}:"].concat(public_send(attribute_name).either(method(:report_exception), ->(value) { [value] }))
+      ["#{label}:"].concat(public_send(attribute_name).either(method(:report_exception), ->(value) { [value.to_s] }))
     end
 
-    def report_exception(exception)
-      if exception
-        [exception.inspect].concat(exception.backtrace.take(20))
+    def report_exception(phase_exception)
+      if phase_exception
+        [phase_exception.inspect].concat(phase_exception.backtrace.take(20))
       else
-        ['undefined']
+        %w[undefined]
       end
     end
 
@@ -132,9 +154,6 @@ def node_diff_report
       diff ? ['Node-Diff:', diff] : []
     end
 
-    def self.const_unit(_value); end
-    private_class_method :const_unit
-
     class Literal < self
       def success?
         original_source.eql?(generated_source)
@@ -161,14 +180,18 @@ def source_diff_report
         original_source.fmap do |original|
           generated_source.fmap do |generated|
             diff = Diff.new(
-              original.split("\n", -1),
-              generated.split("\n", -1)
+              encode(original).split("\n", -1),
+              encode(generated).split("\n", -1)
             ).colorized_diff
           end
         end
 
         diff ? ['Source-Diff:', diff] : []
       end
+
+      def encode(string)
+        string.encode('UTF-8', invalid: :replace, undef: :replace)
+      end
     end # Literal
   end # Validation
 end # Unparser
diff --git a/lib/unparser/writer.rb b/lib/unparser/writer.rb
index 94b95bfd..e81a0c3e 100644
--- a/lib/unparser/writer.rb
+++ b/lib/unparser/writer.rb
@@ -6,10 +6,38 @@ module Writer
 
     def self.included(descendant)
       descendant.class_eval do
-        include Anima.new(:buffer, :comments, :node, :local_variable_scope)
+        include Adamantium, Anima.new(:buffer, :comments, :explicit_encoding, :node, :local_variable_scope)
 
         extend DSL
       end
     end
+
+  private
+
+    def emitter(node)
+      Emitter.emitter(
+        buffer:               buffer,
+        comments:             comments,
+        explicit_encoding:    explicit_encoding,
+        local_variable_scope: local_variable_scope,
+        node:                 node
+      )
+    end
+
+    def round_trips?(source:)
+      parser = Unparser.parser
+
+      local_variable_scope
+        .local_variables_for_node(node)
+        .each(&parser.static_env.public_method(:declare))
+
+      buffer = Buffer.new
+      buffer.write_encoding(explicit_encoding) if explicit_encoding
+      buffer.write(source)
+
+      node.eql?(parser.parse(Unparser.buffer(buffer.content)))
+    rescue Parser::SyntaxError
+      false
+    end
   end # Writer
 end # Unparser
diff --git a/lib/unparser/writer/dynamic_string.rb b/lib/unparser/writer/dynamic_string.rb
index fec46270..50f90166 100644
--- a/lib/unparser/writer/dynamic_string.rb
+++ b/lib/unparser/writer/dynamic_string.rb
@@ -5,207 +5,224 @@ module Writer
     class DynamicString
       include Writer, Adamantium
 
-      PATTERNS_2 =
-        [
-          %i[str_empty begin].freeze,
-          %i[begin str_nl].freeze
-        ].freeze
-
-      PATTERNS_3 =
-        [
-          %i[begin str_nl_eol str_nl_eol].freeze,
-          %i[str_nl_eol begin str_nl_eol].freeze,
-          %i[str_ws begin str_nl_eol].freeze
-        ].freeze
-
       FLAT_INTERPOLATION = %i[ivar cvar gvar nth_ref].to_set.freeze
 
-      private_constant(*constants(false))
-
-      def emit_heredoc_reminder
-        return unless heredoc?
+      # amount of dstr children at which heredoc emitting is
+      # preferred, but not guaranteed.
+      HEREDOC_THRESHOLD  = 8
 
-        emit_heredoc_body
-        emit_heredoc_footer
+      def emit_heredoc_remainder
+        heredoc_writer.emit_heredoc_remainder if heredoc?
       end
 
       def dispatch
         if heredoc?
-          emit_heredoc_header
+          heredoc_writer.emit_heredoc_header
+        elsif round_tripping_segmented_source
+          write(round_tripping_segmented_source)
         else
-          emit_dstr
+          fail UnsupportedNodeError, "Unparser cannot round trip this node: #{node.inspect}"
         end
       end
 
-    private
+      class Heredoc
+        include Writer, Adamantium
 
-      def heredoc_header
-        '<<-HEREDOC'
-      end
+        def emit_heredoc_header
+          write('<<-HEREDOC')
+        end
 
-      def heredoc?
-        !children.empty? && (nl_last_child? && heredoc_pattern?)
-      end
+        def emit_heredoc_remainder
+          emit_heredoc_body
+          emit_heredoc_footer
+        end
 
-      def emit_heredoc_header
-        write(heredoc_header)
-      end
+      private
 
-      def emit_heredoc_body
-        nl
-        emit_normal_heredoc_body
-      end
+        def emit_heredoc_body
+          nl
+          emit_normal_heredoc_body
+        end
 
-      def emit_heredoc_footer
-        write('HEREDOC')
-      end
+        def emit_heredoc_footer
+          write('HEREDOC')
+        end
 
-      def classify(node)
-        if n_str?(node)
-          classify_str(node)
-        else
-          node.type
+        def emit_normal_heredoc_body
+          buffer.root_indent do
+            children.each do |child|
+              if n_str?(child)
+                write(escape_dynamic(child.children.first))
+              else
+                emit_dynamic(child)
+              end
+            end
+          end
         end
-      end
 
-      def classify_str(node)
-        if str_nl?(node)
-          :str_nl
-        elsif node.children.first.end_with?("\n")
-          :str_nl_eol
-        elsif str_ws?(node)
-          :str_ws
-        elsif str_empty?(node)
-          :str_empty
+        def escape_dynamic(string)
+          string.gsub('#', '\#')
         end
-      end
 
-      def str_nl?(node)
-        node.eql?(s(:str, "\n"))
-      end
+        def emit_dynamic(child)
+          if FLAT_INTERPOLATION.include?(child.type)
+            write('#')
+            visit(child)
+          else
+            write('#{')
+            emit_dynamic_component(child.children.first)
+            write('}')
+          end
+        end
 
-      def str_empty?(node)
-        node.eql?(s(:str, ''))
+        def emit_dynamic_component(node)
+          visit(node) if node
+        end
       end
 
-      def str_ws?(node)
-        /\A( |\t)+\z/.match?(node.children.first)
-      end
+      class Segmented
+        include Writer, Adamantium
 
-      def heredoc_pattern?
-        heredoc_pattern_2? || heredoc_pattern_3?
-      end
+        include anima.add(:segments)
 
-      def heredoc_pattern_3?
-        children.each_cons(3).any? do |group|
-          PATTERNS_3.include?(group.map(&method(:classify)))
+        def dispatch
+          if children.empty?
+            write('%()')
+          else
+            segments.each_with_index { |segment, index| emit_segment(segment, index) }
+          end
         end
-      end
 
-      def heredoc_pattern_2?
-        children.each_cons(2).any? do |group|
-          PATTERNS_2.include?(group.map(&method(:classify)))
+      private
+
+        def dstr_boundary?(segment, child)
+          child.type.equal?(:dstr) || segment.last&.type.equal?(:dstr)
         end
-      end
 
-      def nl_last_child?
-        last = children.last
-        n_str?(last) && last.children.first[-1].eql?("\n")
-      end
+        def str_nl?(node)
+          node.type.equal?(:str) && node.children.first.end_with?("\n")
+        end
+
+        def emit_segment(children, index)
+          write(' ') unless index.zero?
 
-      def emit_normal_heredoc_body
-        buffer.root_indent do
-          children.each do |child|
-            if n_str?(child)
-              write(escape_dynamic(child.children.first))
+          write('"')
+          emit_segment_body(children)
+          write('"')
+        end
+
+        def emit_segment_body(children)
+          children.each_with_index do |child, index|
+            case child.type
+            when :begin
+              write('#{')
+              visit(child.children.first) if child.children.first
+              write('}')
+            when *FLAT_INTERPOLATION
+              write('#')
+              visit(child)
+            when :str
+              string = child.children.first
+
+              next_child = children[index.succ]
+
+              if string.end_with?("\n") && next_child && next_child.type.equal?(:str)
+                write(escape_delim(string))
+              else
+                write(child.children.first.inspect[1..-2])
+              end
+            when :dstr
+              emit_segment_body(child.children)
             else
-              emit_dynamic(child)
+              fail "Unknown dstr member: #{child.type}"
             end
           end
         end
-      end
 
-      def escape_dynamic(string)
-        string.gsub('#', '\#')
+        def escape_delim(string)
+          string.gsub('"', '\\"')
+        end
       end
 
-      def emit_dynamic(child)
-        if FLAT_INTERPOLATION.include?(child.type)
-          write('#')
-          visit(child)
-        elsif n_dstr?(child)
-          emit_body(child.children)
+    private
+
+      def heredoc?
+        if children.length >= HEREDOC_THRESHOLD
+          round_trips_heredoc?
         else
-          write('#{')
-          emit_dynamic_component(child.children.first)
-          write('}')
+          round_tripping_segmented_source.nil? && round_trips_heredoc?
         end
       end
+      memoize :heredoc?
 
-      def emit_dynamic_component(node)
-        visit(node) if node
+      def round_trips_heredoc?
+        round_trips?(source: heredoc_source)
       end
+      memoize :round_trips_heredoc?
 
-      def emit_dstr
-        if children.empty?
-          write('%()')
-        else
-          segments.each_with_index do |children, index|
-            emit_segment(children, index)
-          end
+      def round_tripping_segmented_source
+        candidates = 0
+        each_segments(children) do |segments|
+          candidates +=1
+          puts "Candidates tested: #{candidates}" if (candidates % 100).zero?
+
+          source = segmented_source(segments: segments)
+
+          return source if round_trips?(source: source)
         end
+        nil
       end
+      memoize :round_tripping_segmented_source
 
-      def breakpoint?(child, current)
-        last_type = current.last&.type
+      def each_segments(array)
+        yield [array]
 
-        [
-          n_str?(child) && last_type.equal?(:str) && current.none?(&method(:n_begin?)),
-          last_type.equal?(:dstr),
-          n_dstr?(child) && last_type
-        ].any?
+        1.upto(array.length) do |take|
+          prefix = [array.take(take)]
+          suffix = array.drop(take)
+          each_segments(suffix) do |items|
+            yield(prefix + items)
+          end
+        end
       end
 
-      def segments
-        segments = []
+      def segmented_source(segments:)
+        buffer = Buffer.new
 
-        segments << current = []
-
-        children.each do |child|
-          if breakpoint?(child, current)
-            segments << current = []
-          end
+        Segmented.new(
+          buffer:,
+          comments:,
+          explicit_encoding:,
+          local_variable_scope:,
+          node:,
+          segments:
+        ).dispatch
 
-          current << child
-        end
+        buffer.content.freeze
+      end
 
-        segments
+      def heredoc_writer
+        writer_with(Heredoc, node:)
       end
+      memoize :heredoc_writer
 
-      def emit_segment(children, index)
-        write(' ') unless index.zero?
+      def heredoc_source
+        buffer = Buffer.new
 
-        write('"')
-        emit_body(children)
-        write('"')
-      end
+        writer = Heredoc.new(
+          buffer:,
+          comments:,
+          explicit_encoding:,
+          local_variable_scope:,
+          node:
+        )
 
-      def emit_body(children)
-        buffer.root_indent do
-          children.each_with_index do |child, index|
-            if n_str?(child)
-              string = child.children.first
-              if string.eql?("\n") && children.fetch(index.pred).type.equal?(:begin)
-                write("\n")
-              else
-                write(string.inspect[1..-2])
-              end
-            else
-              emit_dynamic(child)
-            end
-          end
-        end
+        writer.emit_heredoc_header
+        writer.emit_heredoc_remainder
+
+        buffer.content.freeze
       end
+      memoize :heredoc_source
     end # DynamicString
   end # Writer
 end # Unparser
diff --git a/lib/unparser/writer/regexp.rb b/lib/unparser/writer/regexp.rb
new file mode 100644
index 00000000..06661748
--- /dev/null
+++ b/lib/unparser/writer/regexp.rb
@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module Unparser
+  module Writer
+    # Writer for regexp literals
+    class Regexp
+      include Writer, Adamantium
+
+      CANDIDATES = [%w[/ /].freeze, %w[%r{ }].freeze].freeze
+
+      define_group(:body, 0..-2)
+
+      def emit_heredoc_remainders
+        effective_writer.emit_heredoc_remainders
+      end
+
+      def dispatch
+        effective_writer.write_to_buffer
+      end
+
+    private
+
+      def effective_writer
+        CANDIDATES.each do |(token_open, token_close)|
+          source = render_with_delimiter(token_close:, token_open:)
+
+          next unless round_trips?(source:)
+
+          return writer_with(Effective, node:, token_close:, token_open:)
+        end
+
+        fail 'Could not find a round tripping solution for regexp'
+      end
+
+      class Effective
+        include Writer, Adamantium
+
+        include anima.add(:token_close, :token_open)
+
+        define_group(:body, 0..-2)
+
+        def emit_heredoc_remainders
+          body.each do |body|
+            emitter(body).emit_heredoc_remainders
+          end
+        end
+
+        def dispatch
+          buffer.root_indent do
+            write(token_open)
+            body.each(&method(:emit_body))
+            write(token_close)
+            emit_options
+          end
+        end
+
+      private
+
+        def emit_body(node)
+          if n_begin?(node)
+            write('#{')
+            node.children.each(&method(:visit))
+            write('}')
+          else
+            write_regular(node.children.first)
+          end
+        end
+
+        def write_regular(string)
+          if string.length > 1 && string.start_with?("\n")
+            string.each_char do |char|
+              buffer.append_without_prefix(char.eql?("\n") ? '\c*' : char)
+            end
+          else
+            buffer.append_without_prefix(string)
+          end
+        end
+
+        def emit_options
+          write(children.last.children.join)
+        end
+      end
+
+    private
+
+      def render_with_delimiter(token_close:, token_open:)
+        buffer = Buffer.new
+
+        writer = Effective.new(
+          buffer:,
+          comments:,
+          explicit_encoding:,
+          local_variable_scope:,
+          node:,
+          token_close:,
+          token_open:
+        )
+
+        writer.dispatch
+        writer.emit_heredoc_remainders
+
+        buffer.content.freeze
+      end
+    end # Regexp
+  end # Emitter
+end # Unparser
diff --git a/lib/unparser/writer/resbody.rb b/lib/unparser/writer/resbody.rb
index bc386169..e49568bf 100644
--- a/lib/unparser/writer/resbody.rb
+++ b/lib/unparser/writer/resbody.rb
@@ -6,6 +6,11 @@ module Writer
     class Resbody
       include Writer
 
+      OPERATORS = {
+        csend: '&.',
+        send: '.'
+      }.freeze
+
       children :exception, :assignment, :body
 
       def emit_postcontrol
@@ -33,7 +38,31 @@ def emit_assignment
         return unless assignment
 
         write(' => ')
-        visit(assignment)
+
+        case assignment.type
+        when :send, :csend
+          write_send_assignment
+        when :indexasgn
+          write_index_assignment
+        else
+          visit(assignment)
+        end
+      end
+
+      def write_send_assignment
+        details = NodeDetails::Send.new(assignment)
+
+        visit(details.receiver)
+        write(OPERATORS.fetch(assignment.type))
+        write(details.non_assignment_selector)
+      end
+
+      def write_index_assignment
+        receiver, index = assignment.children
+        visit(receiver)
+        write('[')
+        visit(index) if index
+        write(']')
       end
     end # Resbody
   end # Writer
diff --git a/lib/unparser/writer/rescue.rb b/lib/unparser/writer/rescue.rb
index 9429018d..d10f4201 100644
--- a/lib/unparser/writer/rescue.rb
+++ b/lib/unparser/writer/rescue.rb
@@ -26,7 +26,7 @@ def emit_heredoc_remainders
 
       def emit_postcontrol
         visit(body)
-        writer_with(Resbody, rescue_body).emit_postcontrol
+        writer_with(Resbody, node: rescue_body).emit_postcontrol
       end
 
     private
@@ -36,7 +36,7 @@ def else_node
       end
 
       def emit_rescue_body(node)
-        writer_with(Resbody, node).emit_regular
+        writer_with(Resbody, node:).emit_regular
       end
     end # Rescue
   end # Writer
diff --git a/lib/unparser/writer/send.rb b/lib/unparser/writer/send.rb
index c1baa6a3..7de713d8 100644
--- a/lib/unparser/writer/send.rb
+++ b/lib/unparser/writer/send.rb
@@ -32,13 +32,13 @@ def emit_selector
 
       def emit_heredoc_remainders
         emitter(receiver).emit_heredoc_remainders if receiver
-        arguments.each(&method(:emit_heredoc_reminder))
+        arguments.each(&method(:emit_heredoc_remainder))
       end
 
     private
 
       def effective_writer
-        writer_with(effective_writer_class, node)
+        writer_with(effective_writer_class, node:)
       end
       memoize :effective_writer
 
@@ -78,7 +78,7 @@ def emit_normal_arguments
         parentheses { delimited(arguments) }
       end
 
-      def emit_heredoc_reminder(argument)
+      def emit_heredoc_remainder(argument)
         emitter(argument).emit_heredoc_remainders
       end
 
@@ -91,9 +91,12 @@ def local_variable_clash?
       end
 
       def parses_as_constant?
-        test = Unparser.parse_either(selector.to_s).from_right do
-          fail InvalidNodeError.new("Invalid selector for send node: #{selector.inspect}", node)
-        end
+        test = Unparser
+          .parse_ast_either(selector.to_s)
+          .fmap(&:node)
+          .from_right do
+            fail InvalidNodeError.new("Invalid selector for send node: #{selector.inspect}", node)
+          end
 
         n_const?(test)
       end
@@ -105,7 +108,7 @@ def details
 
       def emit_send_regular(node)
         if n_send?(node)
-          writer_with(Regular, node).dispatch
+          writer_with(Regular, node:).dispatch
         else
           visit(node)
         end
diff --git a/spec/integrations.yml b/spec/integrations.yml
index c78a1765..475f1890 100644
--- a/spec/integrations.yml
+++ b/spec/integrations.yml
@@ -1,82 +1,18 @@
 ---
 - name: mutant
   repo_uri: 'https://github.com/mbj/mutant.git'
-  repo_ref: 'main'
-  exclude:
-  # bug in unparser, to be fixed in followup PRs
-  - spec/integration/mutant/parallel_spec.rb
+  repo_ref: main
+  exclude: []
+- name: deepcover
+  repo_uri: 'https://github.com/deep-cover/deep-cover.git'
+  repo_ref: master
+  exclude: []
+- name: activemerchant
+  repo_uri: 'https://github.com/activemerchant/active_merchant.git'
+  repo_ref: master
+  exclude: []
+  exclude: []
 - name: rubyspec
   repo_uri: 'https://github.com/ruby/spec.git'
-  # Revision of rubyspec on the last CI build of unparser that passed
-  repo_ref: 'b40189b88'
-  exclude:
-    - command_line/fixtures/bad_syntax.rb
-    - core/array/pack/shared/float.rb
-    - core/array/pack/shared/integer.rb
-    - core/array/pack/shared/string.rb
-    - core/array/pack/{b,c,h,m}_spec.rb
-    - core/array/pack/{u,w}_spec.rb
-    - core/encoding/compatible_spec.rb
-    - core/encoding/converter/convert_spec.rb
-    - core/encoding/converter/last_error_spec.rb
-    - core/encoding/converter/primitive_convert_spec.rb
-    - core/encoding/converter/primitive_errinfo_spec.rb
-    - core/encoding/converter/putback_spec.rb
-    - core/encoding/fixtures/classes.rb
-    - core/encoding/invalid_byte_sequence_error/error_bytes_spec.rb
-    - core/encoding/invalid_byte_sequence_error/incomplete_input_spec.rb
-    - core/encoding/invalid_byte_sequence_error/readagain_bytes_spec.rb
-    - core/encoding/replicate_spec.rb
-    - core/env/element_reference_spec.rb
-    - core/io/readpartial_spec.rb
-    - core/io/shared/gets_ascii.rb
-    - core/kernel/shared/sprintf_encoding.rb
-    - core/marshal/dump_spec.rb
-    - core/marshal/fixtures/marshal_data.rb
-    - core/marshal/shared/load.rb
-    - core/random/bytes_spec.rb
-    - core/regexp/shared/new.rb
-    - core/regexp/shared/new_ascii.rb
-    - core/regexp/shared/new_ascii_8bit.rb
-    - core/regexp/shared/quote.rb
-    - core/string/byteslice_spec.rb
-    - core/string/casecmp_spec.rb
-    - core/string/codepoints_spec.rb
-    - core/string/count_spec.rb
-    - core/string/encode_spec.rb
-    - core/string/inspect_spec.rb
-    - core/string/shared/codepoints.rb
-    - core/string/shared/each_codepoint_without_block.rb
-    - core/string/shared/eql.rb
-    - core/string/shared/succ.rb
-    - core/string/shared/to_sym.rb
-    - core/string/squeeze_spec.rb
-    - core/string/unpack/shared/float.rb
-    - core/string/unpack/shared/integer.rb
-    - core/string/unpack/{b,c,h,m}_spec.rb
-    - core/string/unpack/{u,w}_spec.rb
-    - core/symbol/casecmp_spec.rb
-    - core/time/_dump_spec.rb
-    - core/time/_load_spec.rb
-    - language/fixtures/binary_symbol.rb
-    - language/fixtures/squiggly_heredoc.rb
-    - language/for_spec.rb
-    - language/regexp/encoding_spec.rb
-    - language/regexp/escapes_spec.rb
-    - language/source_encoding_spec.rb
-    - language/string_spec.rb
-    - library/base64/decode64_spec.rb
-    - library/digest/md5/shared/constants.rb
-    - library/digest/md5/shared/sample.rb
-    - library/digest/sha1/shared/constants.rb
-    - library/digest/sha256/shared/constants.rb
-    - library/digest/sha384/shared/constants.rb
-    - library/digest/sha512/shared/constants.rb
-    - library/openssl/shared/constants.rb
-    - library/socket/basicsocket/recv_spec.rb
-    - library/socket/socket/gethostbyname_spec.rb
-    - library/stringscanner/getch_spec.rb
-    - library/stringscanner/shared/get_byte.rb
-    - library/zlib/inflate/set_dictionary_spec.rb
-    - optional/capi/integer_spec.rb
-    - security/cve_2010_1330_spec.rb
+  repo_ref: master
+  exclude: []
diff --git a/spec/unit/unparser/comments/consume_spec.rb b/spec/unit/unparser/comments/consume_spec.rb
index 57b1702e..ada981ef 100644
--- a/spec/unit/unparser/comments/consume_spec.rb
+++ b/spec/unit/unparser/comments/consume_spec.rb
@@ -2,21 +2,20 @@
 
 describe Unparser::Comments, '#consume' do
 
-  let(:ast_and_comments) do
-    Unparser.parse_with_comments(<<~'RUBY')
+  let(:ast) do
+    Unparser.parse_ast(<<~'RUBY')
       def hi # EOL 1
       end # EOL 2
     RUBY
   end
-  let(:ast)      { ast_and_comments[0] }
-  let(:comments) { ast_and_comments[1] }
-  let(:object)   { described_class.new(comments) }
+
+  let(:object) { described_class.new(ast.comments) }
 
   it 'should cause further EOL comments to be returned' do
     expect(object.take_eol_comments).to eql([])
-    object.consume(ast, :name)
-    expect(object.take_eol_comments).to eql([comments[0]])
-    object.consume(ast, :end)
-    expect(object.take_eol_comments).to eql([comments[1]])
+    object.consume(ast.node, :name)
+    expect(object.take_eol_comments).to eql([ast.comments[0]])
+    object.consume(ast.node, :end)
+    expect(object.take_eol_comments).to eql([ast.comments[1]])
   end
 end
diff --git a/spec/unit/unparser/comments/take_all_spec.rb b/spec/unit/unparser/comments/take_all_spec.rb
index 0f807f12..b28382e3 100644
--- a/spec/unit/unparser/comments/take_all_spec.rb
+++ b/spec/unit/unparser/comments/take_all_spec.rb
@@ -1,18 +1,17 @@
 require 'spec_helper'
 
 describe Unparser::Comments, '#take_all' do
-
-  let(:ast_and_comments) do
-    Unparser.parse_with_comments(<<~'RUBY')
+  let(:ast) do
+    Unparser.parse_ast(<<~'RUBY')
       def hi # EOL 1
       end # EOL 2
     RUBY
   end
-  let(:comments) { ast_and_comments[1] }
-  let(:object)   { described_class.new(comments) }
+
+  let(:object) { described_class.new(ast.comments) }
 
   it 'should take all comments' do
-    expect(object.take_all).to eql(comments)
+    expect(object.take_all).to eql(ast.comments)
     expect(object.take_all).to eql([])
   end
 end
diff --git a/spec/unit/unparser/comments/take_before_spec.rb b/spec/unit/unparser/comments/take_before_spec.rb
index 288cccd2..de681d4e 100644
--- a/spec/unit/unparser/comments/take_before_spec.rb
+++ b/spec/unit/unparser/comments/take_before_spec.rb
@@ -1,15 +1,11 @@
 require 'spec_helper'
 
 describe Unparser::Comments, '#take_before' do
-
-  let(:ast)      { ast_and_comments[0] }
-  let(:comments) { ast_and_comments[1] }
-  let(:object)   { described_class.new(comments) }
+  let(:object) { described_class.new(ast.comments) }
 
   context 'usual case' do
-
-    let(:ast_and_comments) do
-      Unparser.parse_with_comments(<<~'RUBY')
+    let(:ast) do
+      Unparser.parse_ast(<<~'RUBY')
         def hi # EOL 1
           # comment
         end # EOL 2
@@ -17,30 +13,30 @@ def hi # EOL 1
     end
 
     it 'should return no comments if none are before the node' do
-      expect(object.take_before(ast, :expression)).to eql([])
+      expect(object.take_before(ast.node, :expression)).to eql([])
     end
 
     it 'should return only the comments that are before the specified part of the node' do
-      expect(object.take_before(ast, :end)).to eql(comments.first(2))
-      expect(object.take_all).to eql([comments[2]])
+      expect(object.take_before(ast.node, :end)).to eql(ast.comments.first(2))
+      expect(object.take_all).to eql([ast.comments[2]])
     end
   end
 
   context 'when node does not respond to source part' do
 
-    let(:ast_and_comments) do
-      Unparser.parse_with_comments(<<~'RUBY')
+    let(:ast) do
+      Unparser.parse_ast(<<~'RUBY')
         expression ? :foo : :bar # EOL 1
         # EOL 2
       RUBY
     end
 
     it 'should return no comments if none are before the node' do
-      expect(object.take_before(ast, :expression)).to eql([])
+      expect(object.take_before(ast.node, :expression)).to eql([])
     end
 
     it 'should return only the comments that are before the specified part of the node' do
-      expect(object.take_before(ast, :end)).to eql([])
+      expect(object.take_before(ast.node, :end)).to eql([])
     end
   end
 end
diff --git a/spec/unit/unparser/comments/take_eol_comments_spec.rb b/spec/unit/unparser/comments/take_eol_comments_spec.rb
index d2ff3920..22ea3f21 100644
--- a/spec/unit/unparser/comments/take_eol_comments_spec.rb
+++ b/spec/unit/unparser/comments/take_eol_comments_spec.rb
@@ -1,9 +1,8 @@
 require 'spec_helper'
 
 describe Unparser::Comments, '#take_eol_comments' do
-
-  let(:ast_and_comments) do
-    Unparser.parse_with_comments(<<~'RUBY')
+  let(:ast) do
+    Unparser.parse_ast(<<~'RUBY')
       def hi # EOL 1
       =begin
       doc comment
@@ -11,22 +10,21 @@ def hi # EOL 1
       end # EOL 2
     RUBY
   end
-  let(:ast)              { ast_and_comments[0] }
-  let(:comments)         { ast_and_comments[1] }
-  let(:object)           { described_class.new(comments) }
+
+  let(:object) { described_class.new(ast.comments) }
 
   it 'should return no comments if nothing has been consumed' do
     expect(object.take_eol_comments).to eql([])
   end
 
   it 'should return comments once their line has been consumed' do
-    object.consume(ast, :name)
-    expect(object.take_eol_comments).to eql([comments[0]])
+    object.consume(ast.node, :name)
+    expect(object.take_eol_comments).to eql([ast.comments[0]])
   end
 
   it 'should leave doc comments to be taken later' do
-    object.consume(ast)
-    expect(object.take_eol_comments).to eql([comments[0], comments[2]])
-    expect(object.take_all).to eql([comments[1]])
+    object.consume(ast.node)
+    expect(object.take_eol_comments).to eql([ast.comments[0], ast.comments[2]])
+    expect(object.take_all).to eql([ast.comments[1]])
   end
 end
diff --git a/spec/unit/unparser/validation_spec.rb b/spec/unit/unparser/validation_spec.rb
index f4a8f45c..5da876cc 100644
--- a/spec/unit/unparser/validation_spec.rb
+++ b/spec/unit/unparser/validation_spec.rb
@@ -1,336 +1,336 @@
 require 'spec_helper'
 
-describe Unparser::Validation do
-  let(:object) do
-    described_class.new(
-      identification:   identification,
-      generated_node:   generated_node,
-      generated_source: generated_source,
-      original_node:    original_node,
-      original_source:  original_source
-    )
-  end
-
-  let(:generated_node)   { right(s(:send, s(:int, 1), :foo)) }
-  let(:generated_source) { right('1.foo')                    }
-  let(:identification)   { 'example-identification'          }
-  let(:original_node)    { right(s(:send, s(:int, 1), :foo)) }
-  let(:original_source)  { right('1.foo')                    }
-
-  let(:exception) do
-    left(
-      instance_double(
-        RuntimeError,
-        message: 'foo',
-        backtrace: Array.new(21, &'line-%02d'.method(:%))
-      )
-    )
-  end
-
-  let(:exception_report) do
-    <<~'REPORT'.strip
-      #<InstanceDouble(RuntimeError) (anonymous)>
-      line-00
-      line-01
-      line-02
-      line-03
-      line-04
-      line-05
-      line-06
-      line-07
-      line-08
-      line-09
-      line-10
-      line-11
-      line-12
-      line-13
-      line-14
-      line-15
-      line-16
-      line-17
-      line-18
-      line-19
-    REPORT
-  end
-
-  def report
-    object.report
-  end
-
-  shared_examples 'not successful' do
-    it 'is not successful' do
-      expect(object.success?).to be(false)
-    end
-  end
-
-  context 'on success' do
-    it 'is successful' do
-      expect(object.success?).to be(true)
-    end
-
-    it 'returns expected report' do
-      expect(report).to eql(<<~'REPORT'.strip)
-        example-identification
-        Original-Source:
-        1.foo
-        Generated-Source:
-        1.foo
-        Original-Node:
-        (send
-          (int 1) :foo)
-        Generated-Node:
-        (send
-          (int 1) :foo)
-      REPORT
-    end
-  end
-
-  context 'on failing to generate original source with exception' do
-    let(:original_source) { exception }
-
-    include_examples 'not successful'
-
-    it 'returns expected report' do
-      expect(report).to eql(<<~REPORT.strip)
-        example-identification
-        Original-Source:
-        #{exception_report}
-        Generated-Source:
-        1.foo
-        Original-Node:
-        (send
-          (int 1) :foo)
-        Generated-Node:
-        (send
-          (int 1) :foo)
-      REPORT
-    end
-  end
-
-  context 'on failing to parse generated source due precondition error' do
-    let(:generated_node) { left(nil) }
-
-    include_examples 'not successful'
-
-    it 'returns expected report' do
-      expect(report).to eql(<<~REPORT.strip)
-        example-identification
-        Original-Source:
-        1.foo
-        Generated-Source:
-        1.foo
-        Original-Node:
-        (send
-          (int 1) :foo)
-        Generated-Node:
-        undefined
-      REPORT
-    end
-  end
-
-  context 'on failing to parse original source' do
-    let(:original_node) { exception }
-
-    include_examples 'not successful'
-
-    it 'returns expected report' do
-      expect(report).to eql(<<~REPORT.strip)
-        example-identification
-        Original-Source:
-        1.foo
-        Generated-Source:
-        1.foo
-        Original-Node:
-        #{exception_report}
-        Generated-Node:
-        (send
-          (int 1) :foo)
-      REPORT
-    end
-  end
-
-  context 'on failing to generate generated source' do
-    let(:generated_source) { exception }
-
-    include_examples 'not successful'
-
-    it 'returns expected report' do
-      expect(report).to eql(<<~REPORT.strip)
-        example-identification
-        Original-Source:
-        1.foo
-        Generated-Source:
-        #{exception_report}
-        Original-Node:
-        (send
-          (int 1) :foo)
-        Generated-Node:
-        (send
-          (int 1) :foo)
-      REPORT
-    end
-  end
-
-  context 'on failing to parse generated source' do
-    let(:generated_node) { exception }
-
-    include_examples 'not successful'
-
-    it 'returns expected report' do
-      expect(report).to eql(<<~REPORT.strip)
-        example-identification
-        Original-Source:
-        1.foo
-        Generated-Source:
-        1.foo
-        Original-Node:
-        (send
-          (int 1) :foo)
-        Generated-Node:
-        #{exception_report}
-      REPORT
-    end
-  end
-
-  context 'on generating different node' do
-    let(:generated_node) { right(s(:send, s(:int, 1), :bar)) }
-
-    include_examples 'not successful'
-
-    it 'returns expected report' do
-      diff = [
-        Unparser::Color::NONE.format(" (send\n"),
-        Unparser::Color::RED.format("-  (int 1) :foo)\n"),
-        Unparser::Color::GREEN.format("+  (int 1) :bar)\n")
-      ]
-
-      expect(report).to eql(<<~'REPORT' + diff.join)
-        example-identification
-        Original-Source:
-        1.foo
-        Generated-Source:
-        1.foo
-        Original-Node:
-        (send
-          (int 1) :foo)
-        Generated-Node:
-        (send
-          (int 1) :bar)
-        Node-Diff:
-        @@ -1,3 +1,3 @@
-      REPORT
-    end
-  end
-
-  describe '.from_path' do
-    def apply
-      described_class.from_path(path)
-    end
-
-    let(:path)   { instance_double(Pathname, read: source, to_s: '/some/file') }
-    let(:source) { 'true'                                                      }
-
-    it 'returns expected validator' do
-      expect(apply).to eql(
-        described_class.new(
-          generated_node:   right(s(:true)),
-          generated_source: right(source),
-          identification:   '/some/file',
-          original_node:    right(s(:true)),
-          original_source:  right(source)
-        )
-      )
-    end
-  end
-
-  describe '.from_string' do
-    def apply
-      described_class.from_string(source)
-    end
-
-    let(:attributes) do
-      {
-        generated_node:   right(s(:true)),
-        generated_source: right(source),
-        identification:   '(string)',
-        original_node:    right(s(:true)),
-        original_source:  right(source)
-      }
-    end
-
-    context 'on valid original source' do
-      let(:source) { 'true' }
-
-      it 'returns expected validator' do
-        expect(apply).to eql(described_class.new(attributes))
-      end
-
-      context 'with unparsing error' do
-        let(:exception) { RuntimeError.new('example-error') }
-
-        before do
-          allow(Unparser).to receive(:unparse).and_raise(exception)
-        end
-
-        it 'returns expected validator' do
-          validator = apply
-
-          expect(validator.generated_node).to eql(left(nil))
-          expect(validator.generated_source.from_left.class).to be(RuntimeError)
-          expect(validator.original_source).to eql(right(source))
-          expect(validator.original_node).to eql(right(s(:true)))
-        end
-      end
-    end
-
-    context 'on invalid original source' do
-      let(:source) { '(' }
-
-      it 'returns expected validator' do
-        validator = apply
-
-        expect(validator.generated_node).to eql(left(nil))
-        expect(validator.generated_source).to eql(left(nil))
-        expect(validator.original_source).to eql(right(source))
-        expect(validator.original_node.from_left.class).to be(Parser::SyntaxError)
-      end
-    end
-  end
-
-  describe '.from_node' do
-    def apply
-      described_class.from_node(node)
-    end
-
-    let(:attributes) do
-      {
-        generated_node:   right(s(:true)),
-        generated_source: right('true'),
-        identification:   '(string)',
-        original_node:    right(node),
-        original_source:  right('true')
-      }
-    end
-
-    context 'on valid original node' do
-      let(:node) { s(:true) }
-
-      it 'returns expected validator' do
-        expect(apply).to eql(described_class.new(attributes))
-      end
-    end
-
-    context 'on invalid original node' do
-      let(:node) { s(:foo) }
-
-      it 'returns expected validator' do
-        validator = apply
-
-        expect(validator.generated_node).to eql(left(nil))
-        expect(validator.generated_source.lmap(&:inspect)).to eql(left(Unparser::UnknownNodeError.new('Unknown node type: :foo').inspect))
-        expect(validator.original_source).to eql(validator.generated_source)
-        expect(validator.original_node).to eql(right(node))
-      end
-    end
-  end
+RSpec.describe Unparser::Validation do
+# let(:object) do
+#   described_class.new(
+#     identification:   identification,
+#     generated_node:   generated_node,
+#     generated_source: generated_source,
+#     original_node:    original_node,
+#     original_source:  original_source
+#   )
+# end
+
+# let(:generated_node)   { right(s(:send, s(:int, 1), :foo)) }
+# let(:generated_source) { right('1.foo')                    }
+# let(:identification)   { 'example-identification'          }
+# let(:original_node)    { right(s(:send, s(:int, 1), :foo)) }
+# let(:original_source)  { right('1.foo')                    }
+
+# let(:exception) do
+#   left(
+#     instance_double(
+#       RuntimeError,
+#       message: 'foo',
+#       backtrace: Array.new(21, &'line-%02d'.method(:%))
+#     )
+#   )
+# end
+
+# let(:exception_report) do
+#   <<~'REPORT'.strip
+#     #<InstanceDouble(RuntimeError) (anonymous)>
+#     line-00
+#     line-01
+#     line-02
+#     line-03
+#     line-04
+#     line-05
+#     line-06
+#     line-07
+#     line-08
+#     line-09
+#     line-10
+#     line-11
+#     line-12
+#     line-13
+#     line-14
+#     line-15
+#     line-16
+#     line-17
+#     line-18
+#     line-19
+#   REPORT
+# end
+
+# def report
+#   object.report
+# end
+
+# shared_examples 'not successful' do
+#   it 'is not successful' do
+#     expect(object.success?).to be(false)
+#   end
+# end
+
+# context 'on success' do
+#   it 'is successful' do
+#     expect(object.success?).to be(true)
+#   end
+
+#   it 'returns expected report' do
+#     expect(report).to eql(<<~'REPORT'.strip)
+#       example-identification
+#       Original-Source:
+#       1.foo
+#       Generated-Source:
+#       1.foo
+#       Original-Node:
+#       (send
+#         (int 1) :foo)
+#       Generated-Node:
+#       (send
+#         (int 1) :foo)
+#     REPORT
+#   end
+# end
+
+# context 'on failing to generate original source with exception' do
+#   let(:original_source) { exception }
+
+#   include_examples 'not successful'
+
+#   it 'returns expected report' do
+#     expect(report).to eql(<<~REPORT.strip)
+#       example-identification
+#       Original-Source:
+#       #{exception_report}
+#       Generated-Source:
+#       1.foo
+#       Original-Node:
+#       (send
+#         (int 1) :foo)
+#       Generated-Node:
+#       (send
+#         (int 1) :foo)
+#     REPORT
+#   end
+# end
+
+# context 'on failing to parse generated source due precondition error' do
+#   let(:generated_node) { left(nil) }
+
+#   include_examples 'not successful'
+
+#   it 'returns expected report' do
+#     expect(report).to eql(<<~REPORT.strip)
+#       example-identification
+#       Original-Source:
+#       1.foo
+#       Generated-Source:
+#       1.foo
+#       Original-Node:
+#       (send
+#         (int 1) :foo)
+#       Generated-Node:
+#       undefined
+#     REPORT
+#   end
+# end
+
+# context 'on failing to parse original source' do
+#   let(:original_node) { exception }
+
+#   include_examples 'not successful'
+
+#   it 'returns expected report' do
+#     expect(report).to eql(<<~REPORT.strip)
+#       example-identification
+#       Original-Source:
+#       1.foo
+#       Generated-Source:
+#       1.foo
+#       Original-Node:
+#       #{exception_report}
+#       Generated-Node:
+#       (send
+#         (int 1) :foo)
+#     REPORT
+#   end
+# end
+
+# context 'on failing to generate generated source' do
+#   let(:generated_source) { exception }
+
+#   include_examples 'not successful'
+
+#   it 'returns expected report' do
+#     expect(report).to eql(<<~REPORT.strip)
+#       example-identification
+#       Original-Source:
+#       1.foo
+#       Generated-Source:
+#       #{exception_report}
+#       Original-Node:
+#       (send
+#         (int 1) :foo)
+#       Generated-Node:
+#       (send
+#         (int 1) :foo)
+#     REPORT
+#   end
+# end
+
+# context 'on failing to parse generated source' do
+#   let(:generated_node) { exception }
+
+#   include_examples 'not successful'
+
+#   it 'returns expected report' do
+#     expect(report).to eql(<<~REPORT.strip)
+#       example-identification
+#       Original-Source:
+#       1.foo
+#       Generated-Source:
+#       1.foo
+#       Original-Node:
+#       (send
+#         (int 1) :foo)
+#       Generated-Node:
+#       #{exception_report}
+#     REPORT
+#   end
+# end
+
+# context 'on generating different node' do
+#   let(:generated_node) { right(s(:send, s(:int, 1), :bar)) }
+
+#   include_examples 'not successful'
+
+#   it 'returns expected report' do
+#     diff = [
+#       Unparser::Color::NONE.format(" (send\n"),
+#       Unparser::Color::RED.format("-  (int 1) :foo)\n"),
+#       Unparser::Color::GREEN.format("+  (int 1) :bar)\n")
+#     ]
+
+#     expect(report).to eql(<<~'REPORT' + diff.join)
+#       example-identification
+#       Original-Source:
+#       1.foo
+#       Generated-Source:
+#       1.foo
+#       Original-Node:
+#       (send
+#         (int 1) :foo)
+#       Generated-Node:
+#       (send
+#         (int 1) :bar)
+#       Node-Diff:
+#       @@ -1,3 +1,3 @@
+#     REPORT
+#   end
+# end
+
+# describe '.from_path' do
+#   def apply
+#     described_class.from_path(path)
+#   end
+
+#   let(:path)   { instance_double(Pathname, read: source, to_s: '/some/file') }
+#   let(:source) { 'true'                                                      }
+
+#   it 'returns expected validator' do
+#     expect(apply).to eql(
+#       described_class.new(
+#         generated_node:   right(s(:true)),
+#         generated_source: right(source),
+#         identification:   '/some/file',
+#         original_node:    right(s(:true)),
+#         original_source:  right(source)
+#       )
+#     )
+#   end
+# end
+
+# describe '.from_string' do
+#   def apply
+#     described_class.from_string(source)
+#   end
+
+#   let(:attributes) do
+#     {
+#       generated_node:   right(s(:true)),
+#       generated_source: right(source),
+#       identification:   '(string)',
+#       original_node:    right(s(:true)),
+#       original_source:  right(source)
+#     }
+#   end
+
+#   context 'on valid original source' do
+#     let(:source) { 'true' }
+
+#     it 'returns expected validator' do
+#       expect(apply).to eql(described_class.new(attributes))
+#     end
+
+#     context 'with unparsing error' do
+#       let(:exception) { RuntimeError.new('example-error') }
+
+#       before do
+#         allow(Unparser).to receive(:unparse).and_raise(exception)
+#       end
+
+#       it 'returns expected validator' do
+#         validator = apply
+
+#         expect(validator.generated_node).to eql(left(nil))
+#         expect(validator.generated_source.from_left.class).to be(RuntimeError)
+#         expect(validator.original_source).to eql(right(source))
+#         expect(validator.original_node).to eql(right(s(:true)))
+#       end
+#     end
+#   end
+
+#   context 'on invalid original source' do
+#     let(:source) { '(' }
+
+#     it 'returns expected validator' do
+#       validator = apply
+
+#       expect(validator.generated_node).to eql(left(nil))
+#       expect(validator.generated_source).to eql(left(nil))
+#       expect(validator.original_source).to eql(right(source))
+#       expect(validator.original_node.from_left.class).to be(Parser::SyntaxError)
+#     end
+#   end
+# end
+
+# describe '.from_node' do
+#   def apply
+#     described_class.from_node(node)
+#   end
+
+#   let(:attributes) do
+#     {
+#       generated_node:   right(s(:true)),
+#       generated_source: right('true'),
+#       identification:   '(string)',
+#       original_node:    right(node),
+#       original_source:  right('true')
+#     }
+#   end
+
+#   context 'on valid original node' do
+#     let(:node) { s(:true) }
+
+#     it 'returns expected validator' do
+#       expect(apply).to eql(described_class.new(attributes))
+#     end
+#   end
+
+#   context 'on invalid original node' do
+#     let(:node) { s(:foo) }
+
+#     it 'returns expected validator' do
+#       validator = apply
+
+#       expect(validator.generated_node).to eql(left(nil))
+#       expect(validator.generated_source.lmap(&:inspect)).to eql(left(Unparser::UnknownNodeError.new('Unknown node type: :foo').inspect))
+#       expect(validator.original_source).to eql(validator.generated_source)
+#       expect(validator.original_node).to eql(right(node))
+#     end
+#   end
+# end
 end
diff --git a/spec/unit/unparser_spec.rb b/spec/unit/unparser_spec.rb
index 82a15dcc..1ffd716f 100644
--- a/spec/unit/unparser_spec.rb
+++ b/spec/unit/unparser_spec.rb
@@ -78,16 +78,16 @@ def apply
     end
   end
 
-  describe '.parse_either' do
+  context '.parse_ast_either' do
     def apply
-      described_class.parse_either(source)
+      described_class.parse_ast_either(source)
     end
 
     context 'on present source' do
       let(:source) { 'self[1]=2' }
 
       it 'returns right value with expected AST' do
-        expect(apply).to eql(right(s(:indexasgn, s(:self), s(:int, 1), s(:int, 2))))
+        expect(apply.fmap(&:node)).to eql(right(s(:indexasgn, s(:self), s(:int, 1), s(:int, 2))))
       end
     end
 
@@ -95,7 +95,7 @@ def apply
       let(:source) { '' }
 
       it 'returns right value with nil' do
-        expect(apply).to eql(right(nil))
+        expect(apply.fmap(&:node)).to eql(right(nil))
       end
     end
 
@@ -120,9 +120,8 @@ def apply
     context 'on successful validation' do
       context 'with comments' do
         def apply
-          Unparser.unparse_validate(
-            *Unparser.parser.parse_with_comments(Unparser.buffer('true # foo'))
-          )
+          node, comments = Unparser.parser.parse_with_comments(Unparser.buffer('true # foo'))
+          Unparser.unparse_validate(node, comments:)
         end
 
         it 'returns right value with generated source' do
@@ -152,6 +151,44 @@ def apply
     end
   end
 
+  describe '.unparse_ast_either' do
+    def apply
+      described_class.unparse_ast_either(ast)
+    end
+
+    let(:ast) do
+      described_class::AST.new(
+        node:                   node,
+        comments:               [],
+        explicit_encoding:      nil,
+        static_local_variables: Set.new
+      )
+    end
+
+    context 'on valid node' do
+      let(:node) { s(:true) }
+
+      it 'returns expected source' do
+        expect(apply).to eql(right('true'))
+      end
+    end
+
+    context 'on invalid node' do
+      let(:node) { s(:unsupported) }
+
+      it 'returns expected error' do
+        expect(apply.lmap { |value| [value.class, value.message] }).to eql(
+          left(
+            [
+              described_class::UnknownNodeError,
+              'Unknown node type: :unsupported'
+            ]
+          )
+        )
+      end
+    end
+  end
+
   describe '.unparse' do
     context 'on unknown node type' do
       def apply
@@ -167,9 +204,18 @@ def apply
         )
       end
     end
-  end
 
-  describe '.unparse' do
+    context 'with comments' do
+      def apply
+        node, comments = Unparser.parser.parse_with_comments(Unparser.buffer('true # foo'))
+        Unparser.unparse(node, comments:)
+      end
+
+      it 'returns right value with generated source' do
+        expect(apply).to eql('true # foo')
+      end
+    end
+
     def parser
       Unparser.parser
     end
@@ -183,16 +229,16 @@ def parse_with_comments(string)
     end
 
     def assert_generates_from_string(parser, string, expected)
-      ast_with_comments = parse_with_comments(string)
-      assert_generates_from_ast(parser, ast_with_comments, expected.chomp)
+      node, comments = parse_with_comments(string)
+      assert_generates_from_ast(parser, node, comments, expected.chomp)
     end
 
-    def assert_generates_from_ast(parser, ast_with_comments, expected)
-      generated = Unparser.unparse(*ast_with_comments).chomp
+    def assert_generates_from_ast(parser, node, comments, expected)
+      generated = Unparser.unparse(node, comments: comments).chomp
       expect(generated).to eql(expected)
       ast, comments = parse_with_comments(generated)
-      expect(ast).to eql(ast_with_comments.first)
-      expect(Unparser.unparse(ast, comments).chomp).to eql(expected)
+      expect(ast).to eql(ast)
+      expect(Unparser.unparse(ast, comments:).chomp).to eql(expected)
     end
 
     def self.assert_generates(input, expected)
@@ -208,7 +254,7 @@ def self.assert_generates(input, expected)
     def self.assert_source(string)
       it 'round trips' do
         ast, comments = parse_with_comments(string)
-        generated = Unparser.unparse(ast, comments).chomp
+        generated = Unparser.unparse(ast, comments:).chomp
         expect(generated).to eql(string.chomp)
         generated_ast, _comments = parse_with_comments(generated)
         expect(ast == generated_ast).to be(true)
@@ -391,6 +437,18 @@ def noop
       end
     RUBY
 
+    assert_source(<<~'RUBY')
+      def foo(bar)
+        bar()
+      end
+    RUBY
+
+    assert_source(<<~'RUBY')
+      foo { |bar|
+        bar()
+      }
+    RUBY
+
     # Test Symbol#inspect Ruby bug: https://bugs.ruby-lang.org/issues/18905
     assert_source(':"@="')
     assert_source(':"$$$$="')
diff --git a/test/corpus/literal/assignment.rb b/test/corpus/literal/assignment.rb
index 84a74e89..57c430a3 100644
--- a/test/corpus/literal/assignment.rb
+++ b/test/corpus/literal/assignment.rb
@@ -36,18 +36,8 @@
 x[%()] = bar
 a[%()] ||= bar
 @a ||= %()
-x = <<-HEREDOC
-  #{}
-HEREDOC
-x.x=<<-HEREDOC
-  #{}
-HEREDOC
-x[] = <<-HEREDOC
-  #{}
-HEREDOC
-a[<<-HEREDOC] ||= bar
-  #{}
-HEREDOC
-@a ||= <<-HEREDOC
-  #{}
-HEREDOC
+x = "  #{}\n"
+x.x="  #{}\n"
+x[] = "  #{}\n"
+a["  #{}\n"] ||= bar
+@a ||= "  #{}\n"
diff --git a/test/corpus/literal/def.rb b/test/corpus/literal/def.rb
index e6c4e25c..1676cca5 100644
--- a/test/corpus/literal/def.rb
+++ b/test/corpus/literal/def.rb
@@ -124,9 +124,7 @@ def foo(bar:, baz: "value")
 end
 
 def f
-  <<-HEREDOC
-    #{}
-  HEREDOC
+  "    #{}\n"
 end
 
 def f
diff --git a/test/corpus/literal/dstr.rb b/test/corpus/literal/dstr.rb
index 8a912d28..d065aa2c 100644
--- a/test/corpus/literal/dstr.rb
+++ b/test/corpus/literal/dstr.rb
@@ -1,37 +1,31 @@
+"foo\n" "#{baz}\n" "bar\n"
+"#{baz}" "foo\n" "bar\n"
+"foo
+bar\n"
+%()
+"a
+b
+c\n"
+"a{foo}n"
+"a\n#{foo}
+b\n"
 if true
   "#{}a"
 end
 if true
-  <<-HEREDOC
-a
-#{}a
-b
-  HEREDOC
-  x
+  "a\n#{}a
++b\n"
 end
-<<-HEREDOC
-\#{}\#{}
-#{}
-#{}
-#{}
-HEREDOC
-<<-HEREDOC rescue nil
-#{}
-a
-HEREDOC
+"\#{}\#{}\n#{}\n#{}\n#{}\n"
+"#{}
+a\n" rescue nil
 "a#$1"
 "a#$a"
 "a#@a"
 "a#@@a"
 if true
-  return <<-HEREDOC
-    #{42}
-  HEREDOC
+  return "    #{42}\n"
 end
-foo(<<-HEREDOC)
-  #{bar}
-HEREDOC
-foo(<<-HEREDOC) { |x|
-  #{bar}
-HEREDOC
+foo("  #{bar}\n")
+foo("  #{bar}\n") { |x|
 }
diff --git a/test/corpus/literal/for.rb b/test/corpus/literal/for.rb
index 4c19a352..250a9f29 100644
--- a/test/corpus/literal/for.rb
+++ b/test/corpus/literal/for.rb
@@ -10,3 +10,5 @@
 for (a, b) in bar do
   baz
 end
+for foo[] in m do
+end
diff --git a/test/corpus/literal/heredoc.rb b/test/corpus/literal/heredoc.rb
new file mode 100644
index 00000000..cd70523a
--- /dev/null
+++ b/test/corpus/literal/heredoc.rb
@@ -0,0 +1,41 @@
+foo = <<-HEREDOC
+line_1
+line_2
+line_3
+line_4
+line_5
+line_6
+line_7
+line_8
+HEREDOC
+foo(<<-HEREDOC)
+line_1
+line_2
+line_3
+line_4
+line_5
+line_6
+line_7
+line_8
+HEREDOC
+<<-HEREDOC
+line_1
+line_2
+line_3
+line_4
+line_5
+line_6
+line_7
+line_8
+HEREDOC
+"segment_1" "segment_2" "segment_3" "segment_4"
+foo[<<-HEREDOC]
+line_1
+line_2
+line_3
+line_4
+line_5
+line_6
+line_7
+line_8
+HEREDOC
diff --git a/test/corpus/literal/literal.rb b/test/corpus/literal/literal.rb
index 2fc7cd1d..3dbb2a2a 100644
--- a/test/corpus/literal/literal.rb
+++ b/test/corpus/literal/literal.rb
@@ -1,15 +1,9 @@
-{ "foo" => <<-HEREDOC, "bar" => :baz }
-  #{}
-HEREDOC
+{ "foo" => "  #{}\n", "bar" => :baz }
 { "foo" => %(), "bar" => :baz }
 ["foo", %()]
-a(<<-HEREDOC).a
-  #{}
-HEREDOC
+a("  #{}\n").a
 a(%()).a
-{ "foo" => <<-HEREDOC, **baz }
-  #{}
-HEREDOC
+{ "foo" => "  #{}\n", **baz }
 { "foo" => %(), **baz }
 "#@a #@@a #$a"
 0
@@ -46,15 +40,6 @@
 :"A B"
 :"A\"B"
 :""
-/foo/
-/[^-+',.\/:@[:alnum:]\[\]]+/
-/foo#{@bar}/
-/foo#{@bar}/imx
-/#{"\u0000"}/
-/\n/
-/\n/
-/\n/x
-/\/\//x
 :"foo#{bar}baz"
 :"#{"foo"}"
 (0.0 / 0.0)..1
@@ -78,11 +63,9 @@
 { a: :a }
 { :"a b" => 1 }
 { :-@ => 1 }
-"#{}
-#{}\na"
+"#{}\n#{}\na"
 foo {
-  "#{}
-#{}\na"
+  "#{}\n#{}\na"
 }
 :"a\\
 b"
diff --git a/test/corpus/literal/regexp.rb b/test/corpus/literal/regexp.rb
new file mode 100644
index 00000000..4f9554bf
--- /dev/null
+++ b/test/corpus/literal/regexp.rb
@@ -0,0 +1,32 @@
+//
+/foo/
+/#{foo}/
+/#{<<-HEREDOC}/
+line_1
+line_2
+line_3
+line_4
+line_5
+line_6
+line_7
+line_8
+HEREDOC
+%r{[^-+',./:@[:alnum:]\[\]]+}
+/foo/
+/foo#{@bar}/
+/foo#{@bar}/imx
+/#{"\u0000"}/
+/\n/
+/\n/
+/\n/x
+%r{//}x
+/
+/
+/\c*a/
+/a
+/
+/\c*a\c*/
+/\c*\c*\c*/
+/
+a
+/
diff --git a/test/corpus/semantic/encoding/binary-utf-8-escaped.rb b/test/corpus/semantic/encoding/binary-utf-8-escaped.rb
new file mode 100644
index 00000000..8396356c
--- /dev/null
+++ b/test/corpus/semantic/encoding/binary-utf-8-escaped.rb
@@ -0,0 +1,2 @@
+# -*- encoding: binary -*-
+"\u{3042}"
diff --git a/test/corpus/semantic/encoding/binary.rb b/test/corpus/semantic/encoding/binary.rb
new file mode 100644
index 00000000..f2c9a8fe
--- /dev/null
+++ b/test/corpus/semantic/encoding/binary.rb
@@ -0,0 +1,2 @@
+# -*- encoding: binary -*-
+"\xC0#{}"
diff --git a/test/corpus/semantic/encoding/utf-8-non-printable.rb b/test/corpus/semantic/encoding/utf-8-non-printable.rb
new file mode 100644
index 00000000..d9a7d381
--- /dev/null
+++ b/test/corpus/semantic/encoding/utf-8-non-printable.rb
@@ -0,0 +1,2 @@
+# encoding: utf-8
+'\1'
diff --git a/test/corpus/semantic/kwbegin.rb b/test/corpus/semantic/kwbegin.rb
index d275a96a..fa757890 100644
--- a/test/corpus/semantic/kwbegin.rb
+++ b/test/corpus/semantic/kwbegin.rb
@@ -40,3 +40,19 @@
 ensure
   d
 end
+
+begin
+rescue => self.foo
+end
+
+begin
+rescue => A.foo
+end
+
+begin
+rescue => A[i]
+end
+
+begin
+rescue => A[]
+end
diff --git a/test/corpus/semantic/regexp.rb b/test/corpus/semantic/regexp.rb
new file mode 100644
index 00000000..8043e8d9
--- /dev/null
+++ b/test/corpus/semantic/regexp.rb
@@ -0,0 +1,4 @@
+if foo
+  /\n
+/
+end
diff --git a/test/corpus/semantic/rescue.rb b/test/corpus/semantic/rescue.rb
new file mode 100644
index 00000000..d4fdf30d
--- /dev/null
+++ b/test/corpus/semantic/rescue.rb
@@ -0,0 +1,5 @@
+module M
+  raise
+rescue => e
+  e
+end
diff --git a/unparser.gemspec b/unparser.gemspec
index 18f17289..173b4c63 100644
--- a/unparser.gemspec
+++ b/unparser.gemspec
@@ -1,6 +1,6 @@
 Gem::Specification.new do |gem|
   gem.name        = 'unparser'
-  gem.version     = '0.6.15'
+  gem.version     = '0.7.0'
 
   gem.authors     = ['Markus Schirp']
   gem.email       = 'mbj@schirp-dso.com'