henitai 0.5.1 → 0.6.0

data/lib/henitai/mutant/activator.rb

@@ -7,10 +7,16 @@ module Henitai
   class Mutant
     # Activates a mutant inside the forked child process.
     class Activator
+      SubjectNotLoadedError = LexicalTarget::SubjectNotLoadedError
+
+      # File name the activation source is evaluated under. It decides what
+      # +__FILE__+ and +__LINE__+ mean inside an activated mutant.
+      EVAL_FILE = __FILE__
+
       # Filters "already initialized constant" C-level warnings that fire when
       # a source file is loaded into a process that already has the constant
       # defined via require. Uses a thread-local flag so the filter is active
-      # only during load_source_file, leaving all other warnings untouched.
+      # only during LexicalTarget#load_source_file, leaving all other warnings untouched.
       module ConstantRedefinitionFilter
         PATTERN = /already initialized constant|previous definition of/
         private_constant :PATTERN
@@ -27,23 +33,34 @@ module Henitai
         new.activate!(mutant)
       end
 
-      # Returns the +define_method+ source string for +mutant+ without
-      # actually evaluating it. Used to pre-compute activation recipes.
-      # Returns nil if the source cannot be computed (e.g. unsupported AST node).
-      def self.activation_source_for(mutant)
-        new.send(:method_source, mutant)
+      # Returns the Activation for +mutant+ without evaluating it: a real
+      # +def+ in the original lexical scope when the subject can be reopened
+      # (ADR-13), otherwise the +define_method+ fallback. Used by the fidelity
+      # check and to pre-compute activation recipes. Returns nil if the source
+      # cannot be computed (e.g. unsupported AST node).
+      def self.activation_for(mutant)
+        new.activation_for(mutant)
       rescue StandardError
         nil
       end
 
+      def self.activation_source_for(mutant)
+        activation_for(mutant)&.source
+      end
+
+      def activation_for(mutant)
+        DefInjection.build(mutant, def_replacement(mutant)) ||
+          Activation.new(source: method_source(mutant), mode: :class_eval, file: EVAL_FILE)
+      end
+
       def activate!(mutant)
         subject = mutant.subject
         raise ArgumentError, "Cannot activate wildcard subjects" if subject.method_name.nil?
 
-        source = mutant.precomputed_activation_source || method_source(mutant)
-        target = target_for(subject)
+        activation = mutant.precomputed_activation || activation_for(mutant)
+        target = activation.mode == :toplevel ? LexicalTarget.resolve(subject, activation) : target_for(subject)
         Henitai::WarningSilencer.silence do
-          target.class_eval(source, __FILE__, __LINE__ + 1)
+          evaluate(activation, target, subject)
           nil
         end
       rescue Unparser::UnsupportedNodeError, SyntaxError
@@ -52,8 +69,44 @@ module Henitai
 
       private
 
+      def evaluate(activation, target, subject)
+        return inject_def(activation, target, subject) if activation.mode == :toplevel
+
+        target.class_eval(activation.source, EVAL_FILE, __LINE__)
+      end
+
+      # A re-evaluated +def+ is public, so the method's visibility -- or its
+      # +module_function+ copy -- is read before and restored after. +target+
+      # is already the singleton class for a class method.
+      def inject_def(activation, target, subject)
+        name = subject.method_name.to_sym
+        visibility = visibility_of(target, name)
+        copy = module_function_copy?(target, name, subject)
+        TOPLEVEL_BINDING.eval(activation.source, activation.file, activation.line)
+        return target.send(:module_function, name) if copy
+
+        target.send(visibility, name) if visibility
+      end
+
+      def visibility_of(owner, name)
+        return :private if owner.private_method_defined?(name)
+
+        :protected if owner.protected_method_defined?(name)
+      end
+
+      def module_function_copy?(target, name, subject)
+        subject.method_type == :instance && !target.is_a?(Class) &&
+          target.private_method_defined?(name) && target.singleton_class.method_defined?(name) &&
+          target.instance_method(name).source_location == target.method(name).source_location
+      end
+
+      def def_replacement(mutant)
+        original_range = mutant.original_node&.location&.expression
+        replacement_source(mutant, original_range) if original_range
+      end
+
       def target_for(subject)
-        target = load_target(subject)
+        target = LexicalTarget.load_target(subject)
         subject.method_type == :class ? target.singleton_class : target
       end
 
@@ -73,7 +126,8 @@ module Henitai
         <<~RUBY
           __henitai_module_function__ = !is_a?(Class) &&
             private_method_defined?(:#{method_name}) &&
-            singleton_class.method_defined?(:#{method_name})
+            singleton_class.method_defined?(:#{method_name}) &&
+            instance_method(:#{method_name}).source_location == method(:#{method_name}).source_location
           define_method(:#{method_name}) do |#{parameters}|
             #{replacement}
           end
@@ -96,8 +150,13 @@ module Henitai
         location = body.location
         return source_body(location, body) unless original_range && location
 
-        replacement = compile_safe_unparse(mutant.mutated_node)
-        body_source_for_location(location, original_range, replacement, body)
+        body_source_for_location(location, original_range, replacement_source(mutant, original_range), body)
+      end
+
+      # An unmutated control keeps the original text: re-rendering it would
+      # test the unparser, not the activation path.
+      def replacement_source(mutant, original_range)
+        Replacement.render(mutant, original_range)
       end
 
       def body_source_for_location(location, original_range, replacement, body)
@@ -157,55 +216,16 @@ module Henitai
       end
 
       def expression_source(location, original_range, replacement)
-        source_range = location.expression
-        return unless source_range
-
-        replace_source_fragment(source_range, original_range, replacement)
-      end
-
-      def load_target(subject)
-        Object.const_get(subject.namespace.delete_prefix("::"))
-      rescue NameError
-        load_source_file(subject)
-        Object.const_get(subject.namespace.delete_prefix("::"))
-      end
-
-      def load_source_file(subject)
-        source_file = subject.source_file || source_file_from_ast(subject)
-        return unless source_file && File.file?(source_file)
-
-        Thread.current[:henitai_filter_const_warnings] = true
-        load(source_file)
-        loaded_feature = File.expand_path(source_file)
-        $LOADED_FEATURES << loaded_feature unless $LOADED_FEATURES.include?(loaded_feature)
-      ensure
-        Thread.current[:henitai_filter_const_warnings] = false
-      end
-
-      def source_file_from_ast(subject)
-        ast_node = subject.ast_node
-        return unless ast_node
-
-        location = ast_node.location
-        return unless location
-
-        expression = location.expression
-        return unless expression
-
-        expression.source_buffer.name
+        replace_source_fragment(location.expression, original_range, replacement)
       end
 
       def replace_source_fragment(source_range, original_range, replacement)
         source = source_range.source
         start = original_range.begin_pos - source_range.begin_pos
         stop = original_range.end_pos - source_range.begin_pos
-        return unless start >= 0 && stop <= source.bytesize && start <= stop
-
-        prefix = source.byteslice(0, start)
-        suffix = source.byteslice(stop, source.bytesize - stop)
-        return unless prefix && suffix
+        return unless start >= 0 && stop <= source.length && start <= stop
 
-        prefix + replacement + suffix
+        source[0, start] + replacement + source[stop..]
       end
 
       def compile_safe_unparse(node)

data/lib/henitai/mutant/def_injection.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+module Henitai
+  class Mutant
+    # Builds the :toplevel activation for a mutant (ADR-13): the subject's
+    # own +def+, with the mutation spliced in, wrapped in the module and class
+    # openers that surround it in the source.
+    #
+    # Re-evaluating a real +def+ in its lexical scope keeps everything a
+    # +define_method+ block loses: constant lookup through the enclosing
+    # modules, implicit +super+, +yield+ and +block_given?+, the exact
+    # parameter list, +__FILE__+ and +__LINE__+, and the file's
+    # +frozen_string_literal+ comment. Visibility is restored by the Activator.
+    #
+    # Returns nil when the subject cannot be reopened this way (a
+    # +define_method+ subject, a method in +class << obj+, a subject without
+    # recorded scope); the Activator then falls back to +define_method+.
+    class DefInjection
+      # Matches +# key: value+ and the emacs form +# -*- key: value -*-+ only,
+      # so prose that merely mentions a magic comment does not match.
+      MAGIC_COMMENT = /
+        \A\#\s*(?:-\*-(?:[^;:]*:[^;]*;)*\s*)?
+        (?:frozen_string_literal|shareable_constant_value|warn_indent)\s*:
+      /ix
+
+      def self.build(mutant, replacement)
+        new.build(mutant, replacement)
+      end
+
+      def build(mutant, replacement)
+        subject = mutant.subject
+        node = subject.ast_node
+        scope = subject.lexical_scope
+        return unless injectable?(node, scope)
+
+        def_source = spliced_def(node.location.expression, mutant.original_node, replacement)
+        return unless def_source
+
+        assemble(node, scope, def_source)
+      end
+
+      private
+
+      # A top-level +def Other.name+ has no openers; an instance method needs
+      # at least one, or it would land on Object.
+      def injectable?(node, scope)
+        return false unless node && scope
+
+        node.type == :defs || (node.type == :def && !scope.empty?)
+      end
+
+      # Splices by character offsets, as parser ranges count characters. A
+      # heredoc's expression range covers only its opener, so the bodies of
+      # heredocs inside the replaced node are removed as well; otherwise they
+      # would stay behind as code.
+      def spliced_def(def_range, original_node, replacement)
+        original_range = original_node&.location&.expression
+        return unless original_range && within?(original_range, def_range)
+        # An unmutated control splices the original text back. Its heredoc
+        # bodies must stay, so the def is used verbatim.
+        return def_range.source if replacement == original_range.source
+
+        edits = heredoc_bodies(original_node).map { |range| [range, ""] } << [original_range, replacement]
+        apply(def_range, edits)
+      end
+
+      # Applies non-overlapping edits from the last to the first, so earlier
+      # offsets stay valid.
+      def apply(def_range, edits)
+        edits.sort_by { |range, _| -range.begin_pos }.each_with_object(def_range.source.dup) do |(range, insert), text|
+          start = range.begin_pos - def_range.begin_pos
+          text[start...(range.end_pos - def_range.begin_pos)] = insert
+        end
+      end
+
+      def heredoc_bodies(node)
+        return [] unless node.is_a?(Parser::AST::Node)
+
+        own = node.location.respond_to?(:heredoc_body) && node.location.heredoc_body
+        bodies = own ? [own.join(node.location.heredoc_end)] : []
+        bodies + node.children.flat_map { |child| heredoc_bodies(child) }
+      end
+
+      def within?(inner, outer)
+        inner.begin_pos.between?(outer.begin_pos, inner.end_pos) && inner.end_pos <= outer.end_pos
+      end
+
+      def assemble(node, scope, def_source)
+        def_range = node.location.expression
+        prefix = prefix_lines(def_range)
+        Activation.new(source: source_lines(prefix, scope, def_source), mode: :toplevel,
+                       **location_fields(def_range, prefix), **owner_fields(node, scope))
+      end
+
+      # Only magic-comment header lines precede the def; the openers share
+      # its line, so the def keeps its original line number.
+      def prefix_lines(def_range)
+        magic_comments(def_range.source_buffer.source)
+      end
+
+      def location_fields(def_range, prefix)
+        { file: File.expand_path(def_range.source_buffer.name),
+          line: [def_range.line - prefix.size, 1].max, def_offset: prefix.size }
+      end
+
+      def owner_fields(node, scope)
+        { lexical_scope: scope, owner: owner_source(node), singleton: node.type == :defs }
+      end
+
+      # The expression the +def+ is defined on, as the openers must evaluate
+      # it: +self+, or the receiver of +def Other.name+.
+      def owner_source(node)
+        node.type == :defs ? node.children.first.location.expression.source : "self"
+      end
+
+      # The expression starts at column 0, so its leading indent is dropped.
+      def source_lines(prefix, scope, def_source)
+        lines = prefix + [wrap_in_scope(def_source.lstrip, scope)]
+        "#{lines.join("\n")}\n"
+      end
+
+      # Openers and closers go on the def's own line; with an empty scope
+      # the def stands alone.
+      def wrap_in_scope(definition, scope)
+        return definition if scope.empty?
+
+        "#{scope.join('; ')}; #{definition}; #{Array.new(scope.size, 'end').join('; ')}"
+      end
+
+      def magic_comments(file_source)
+        header = file_source.each_line.take_while { |line| line.strip.empty? || line.start_with?("#") }
+        header.map(&:chomp).grep(MAGIC_COMMENT)
+      end
+    end
+  end
+end

data/lib/henitai/mutant/lexical_scope_check.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module Henitai
+  class Mutant
+    # Decides whether the scope openers of an activation can be reopened.
+    #
+    # Evaluating an opener such as "class Inner" creates the class when it is
+    # missing, which would inject a mutant into an empty phantom class. This
+    # check walks the openers the way Ruby resolves them, but never evaluates
+    # them, so it never defines a constant.
+    class LexicalScopeCheck
+      CLASS_EVAL_SUFFIX = ".class_eval do"
+      SINGLETON_PREFIX = "class << "
+
+      # The lexical nesting (innermost first, ending with Object, mirroring
+      # Ruby's cref chain) and the current +self+, which a class_eval block
+      # changes without changing the nesting.
+      Scope = Data.define(:nesting, :receiver)
+
+      def self.resolves?(openers)
+        new.resolves?(openers)
+      end
+
+      def resolves?(openers)
+        scope = Scope.new(nesting: [Object], receiver: Object)
+        openers.all? { |opener| scope = next_scope(opener, scope) }
+      end
+
+      private
+
+      def next_scope(opener, scope)
+        return singleton_scope(opener, scope) if opener.start_with?(SINGLETON_PREFIX)
+        return class_eval_scope(opener, scope) if opener.end_with?(CLASS_EVAL_SUFFIX)
+
+        target = opener_target(opener, scope)
+        target && Scope.new(nesting: [target, *scope.nesting], receiver: target)
+      end
+
+      # A singleton opener cannot create a constant, but its receiver must
+      # resolve; its singleton class becomes both the cref and +self+.
+      def singleton_scope(opener, scope)
+        found, value = resolve_expression(opener.delete_prefix(SINGLETON_PREFIX), scope)
+        return unless found
+
+        singleton = value.singleton_class
+        Scope.new(nesting: [singleton, *scope.nesting], receiver: singleton)
+      rescue TypeError
+        nil
+      end
+
+      # A block evaluated with class_eval keeps the enclosing constant lookup
+      # and only changes +self+ to its receiver.
+      def class_eval_scope(opener, scope)
+        found, value = resolve_expression(opener.delete_suffix(CLASS_EVAL_SUFFIX), scope)
+        found && value.is_a?(Module) && scope.with(receiver: value)
+      end
+
+      def opener_target(opener, scope)
+        kind, path = opener.split(" ", 2)
+        segments = path.delete_prefix("::").split("::")
+        parent = path.start_with?("::") ? walk(Object, segments[0...-1]) : parent_of(segments[0...-1], scope)
+        value = parent.is_a?(Module) && constant_value(parent, segments.last)
+        value if matches_kind?(value, kind)
+      end
+
+      # Resolves a constant expression such as +Point+, +self::Inner+ or
+      # +::Outer::Point+. Returns whether it resolved and its value.
+      def resolve_expression(path, scope)
+        return [true, scope.receiver] if path == "self"
+
+        value = path.match?(/\A\w+\z/) ? lexical_lookup(path, scope.nesting) : qualified_value(path, scope)
+        [!value.nil?, value]
+      end
+
+      def qualified_value(path, scope)
+        segments = path.delete_prefix("::").split("::")
+        base = path.start_with?("::") ? Object : parent_of(segments.first(1), scope)
+        walk(base, segments.drop(path.start_with?("::") ? 0 : 1))
+      end
+
+      # A leading +self+ (as in +class self::Inner+) is the current receiver.
+      def parent_of(segments, scope)
+        return scope.nesting.first if segments.empty?
+
+        first = segments.first == "self" ? scope.receiver : lexical_lookup(segments.first, scope.nesting)
+        walk(first, segments.drop(1))
+      end
+
+      def walk(base, segments)
+        segments.reduce(base) { |current, name| current.is_a?(Module) ? own_constant(current, name) : nil }
+      end
+
+      # Ruby's order: the own constants of each lexical scope (innermost
+      # first, without Object), then the ancestors of the innermost scope,
+      # then the top level.
+      def lexical_lookup(name, nesting)
+        scope = nesting[0...-1].find { |candidate| candidate.const_defined?(name, false) }
+        return scope.const_get(name, false) if scope
+
+        innermost = nesting.first
+        innermost.const_get(name) if innermost.const_defined?(name) || Object.const_defined?(name)
+      end
+
+      def own_constant(base, name)
+        base.const_get(name, false) if base.const_defined?(name, false)
+      end
+
+      def constant_value(parent, name)
+        inherit = parent.equal?(Object)
+        parent.const_get(name, inherit) if parent.const_defined?(name, inherit)
+      end
+
+      def matches_kind?(value, kind)
+        return false unless value.is_a?(Module)
+
+        kind == "class" ? value.is_a?(Class) : !value.is_a?(Class)
+      end
+    end
+  end
+end

data/lib/henitai/mutant/lexical_target.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module Henitai
+  class Mutant
+    # Resolves the object a re-evaluated +def+ must be defined on, and loads
+    # the subject's source file when its namespace is still undefined.
+    class LexicalTarget
+      # Raised when a subject's namespace is still undefined after its source
+      # file was loaded, so there is no class to reopen.
+      class SubjectNotLoadedError < StandardError; end
+
+      def self.resolve(subject, activation)
+        new.resolve(subject, activation)
+      end
+
+      def self.load_target(subject)
+        new.load_target(subject)
+      end
+
+      # The object the re-evaluated +def+ defines its method on, as Ruby
+      # resolves it: the openers are evaluated with +self+ -- or the receiver
+      # of +def Other.name+ -- as their body. The subject's namespace is only
+      # the resolver's static reading of the source, which cannot tell
+      # whether +Other+ inside +module Outer+ is +Outer::Other+ or +::Other+.
+      # The scope, owner and singleton flag come from the activation, so a
+      # replayed recipe does not need the AST. The subject's file is loaded
+      # first when needed (see +ensure_loaded+), so that evaluating the openers
+      # reopens the loaded class instead of creating an empty one.
+      def resolve(subject, activation)
+        scope = activation.lexical_scope
+        ensure_loaded(subject, scope)
+        source = "#{scope.join('; ')}\n#{activation.owner}\n#{Array.new(scope.size, 'end').join('; ')}"
+        owner = TOPLEVEL_BINDING.eval(source, activation.file, activation.line)
+        activation.singleton ? owner.singleton_class : owner
+      end
+
+      def load_target(subject)
+        Object.const_get(subject.namespace)
+      rescue NameError
+        load_source_file(subject)
+        Object.const_get(subject.namespace)
+      end
+
+      private
+
+      # Evaluating the openers must reopen existing constants, never create
+      # them: a missing class would become an empty phantom that swallows the
+      # mutant. The scope is therefore checked without evaluation first. If it
+      # does not resolve, the subject's file is loaded and checked again. If it
+      # still does not resolve, activation fails instead of creating anything.
+      def ensure_loaded(subject, scope)
+        return load_toplevel_source(subject) if scope.empty?
+        return if LexicalScopeCheck.resolves?(scope)
+
+        load_subject_source(subject)
+        return if LexicalScopeCheck.resolves?(scope)
+
+        raise SubjectNotLoadedError,
+              "cannot activate #{subject.expression}: its source did not define #{subject.namespace}"
+      end
+
+      # Without openers no phantom class can be created; the file is loaded
+      # only when the subject's namespace constant is still missing. A file
+      # that fails to load fails the activation instead of crashing the child.
+      def load_toplevel_source(subject)
+        load_target(subject)
+      rescue NameError
+        nil
+      rescue StandardError, ScriptError => e
+        raise SubjectNotLoadedError, "cannot activate #{subject.namespace}: its source failed to load (#{e.message})"
+      end
+
+      def load_subject_source(subject)
+        load_source_file(subject)
+      rescue StandardError, ScriptError => e
+        raise SubjectNotLoadedError, "cannot activate #{subject.namespace}: its source failed to load (#{e.message})"
+      end
+
+      def load_source_file(subject)
+        source_file = subject.source_file || source_file_from_ast(subject)
+        return unless source_file && File.file?(source_file)
+
+        Thread.current[:henitai_filter_const_warnings] = true
+        load(source_file)
+        loaded_feature = File.expand_path(source_file)
+        $LOADED_FEATURES << loaded_feature unless $LOADED_FEATURES.include?(loaded_feature)
+      ensure
+        Thread.current[:henitai_filter_const_warnings] = false
+      end
+
+      def source_file_from_ast(subject)
+        ast_node = subject.ast_node
+        return unless ast_node
+
+        location = ast_node.location
+        return unless location
+
+        expression = location.expression
+        return unless expression
+
+        expression.source_buffer.name
+      end
+    end
+  end
+end

data/lib/henitai/mutant/replacement.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "unparser"
+
+module Henitai
+  class Mutant
+    # Renders the source text spliced in place of a mutant's original node.
+    #
+    # The text replaces only the original node's range, so it must parse as
+    # one expression wherever it lands. An operator expression such as
+    # `a || b` does not: spliced into `a && b && c` it reads as
+    # `a || (b && c)`. Operator expressions are therefore parenthesised;
+    # parentheses never change an expression's meaning, missing ones can. An
+    # unmutated control keeps the original text.
+    class Replacement
+      OPERATOR_METHODS = %i[
+        + - * / % ** == != < > <= >= <=> === =~ !~ << >> & | ^ ! ~ -@ +@
+      ].freeze
+
+      def self.render(mutant, original_range)
+        new(mutant, original_range).render
+      end
+
+      def initialize(mutant, original_range)
+        @mutant = mutant
+        @original_range = original_range
+      end
+
+      def render
+        return @original_range.source if @mutant.mutated_node.equal?(@mutant.original_node)
+
+        text = unparse(@mutant.mutated_node)
+        operator_expression?(@mutant.mutated_node) ? "(#{text})" : text
+      end
+
+      private
+
+      def unparse(node)
+        Unparser.unparse(node)
+      rescue StandardError => e
+        raise Unparser::UnsupportedNodeError, e.message
+      end
+
+      def operator_expression?(node)
+        return false unless node.is_a?(Parser::AST::Node)
+        return true if %i[and or].include?(node.type)
+
+        %i[send csend].include?(node.type) && OPERATOR_METHODS.include?(node.children[1])
+      end
+    end
+  end
+end

data/lib/henitai/mutant.rb

@@ -21,6 +21,11 @@ module Henitai
 
     autoload :Activator, "henitai/mutant/activator"
     autoload :ParameterSource, "henitai/mutant/parameter_source"
+    autoload :Activation, "henitai/mutant/activation"
+    autoload :LexicalScopeCheck, "henitai/mutant/lexical_scope_check"
+    autoload :LexicalTarget, "henitai/mutant/lexical_target"
+    autoload :DefInjection, "henitai/mutant/def_injection"
+    autoload :Replacement, "henitai/mutant/replacement"
 
     # Status-Vokabular folgt dem Stryker mutation-testing-report-schema.
     # :equivalent ist ein Henitai-interner Status (wird im JSON als "Ignored" serialisiert,
@@ -40,9 +45,12 @@ module Henitai
 
     attr_reader :id, :subject, :operator, :original_node, :mutated_node,
                 :mutation_type, :description, :location,
-                :precomputed_stable_id, :precomputed_activation_source
+                :precomputed_stable_id, :precomputed_activation, :precomputed_replacement
     attr_accessor :status, :killing_test, :duration, :covered_by, :tests_completed,
-                  :ignore_reason, :from_cache
+                  :ignore_reason, :status_reason, :from_cache
+    # Set by MutantGenerator only for mutants whose identity would otherwise
+    # collide with another one (see MutantIdentity).
+    attr_accessor :identity_discriminator
 
     # @param subject [Subject] the subject being mutated
     # @param operator [Symbol] operator name, e.g. :ArithmeticOperator
@@ -51,7 +59,8 @@ module Henitai
     # @param location [Hash] { file:, start_line:, end_line:, start_col:, end_col: }
     # rubocop:disable Metrics/ParameterLists
     def initialize(subject:, operator:, nodes:, description:, location:,
-                   precomputed_stable_id: nil, precomputed_activation_source: nil)
+                   precomputed_stable_id: nil, precomputed_activation: nil,
+                   precomputed_replacement: nil)
       @id            = SecureRandom.uuid
       @subject       = subject
       @operator      = operator
@@ -60,10 +69,9 @@ module Henitai
       @description   = description
       @location      = location
       @precomputed_stable_id = precomputed_stable_id
-      @precomputed_activation_source = precomputed_activation_source
-      @status = :pending
-      @killing_test = @duration = @covered_by = @tests_completed = @ignore_reason = nil
-      @from_cache = false
+      @precomputed_activation = precomputed_activation
+      @precomputed_replacement = precomputed_replacement
+      reset_outcome
     end
     # rubocop:enable Metrics/ParameterLists
 
@@ -73,7 +81,9 @@ module Henitai
 
     # Unparsing is expensive and the value is needed by both the JSON and
     # the terminal reporter — compute once per mutant.
-    def mutated_source = @mutated_source ||= safe_unparse(mutated_node)
+    def mutated_source
+      @mutated_source ||= @precomputed_replacement || safe_unparse(mutated_node)
+    end
 
     def killed?      = @status == :killed
     def from_cache?  = @from_cache == true
@@ -85,5 +95,14 @@ module Henitai
     def to_s
       "#{operator}@#{location[:file]}:#{location[:start_line]} — #{description}"
     end
+
+    private
+
+    def reset_outcome
+      @status = :pending
+      @killing_test = @duration = @covered_by = @tests_completed = nil
+      @ignore_reason = @status_reason = nil
+      @from_cache = false
+    end
   end
 end