feat: Refactor ValueEvaluation and Evaluation structs for improved memory management and simplify assignment operations

Author: gedaiu

docs/src/content/docs/guide/memory-management.mdx

@@ -129,18 +129,18 @@ This happens automatically - **you don't need to call any special methods** when
 
 ### Nested Structs
 
-When a struct contains members with postblit constructors, D automatically calls postblit on each member:
+When a struct contains members with postblit constructors, D automatically calls postblit on each member - **no explicit postblit is needed** in the containing struct:
 
 ```d
 struct ValueEvaluation {
     HeapString strValue;   // Has postblit
     HeapString niceValue;  // Has postblit
+    HeapString fileName;   // Has postblit
+    HeapString prependText; // Has postblit
 
-    // D automatically calls strValue.this(this) and niceValue.this(this)
+    // No explicit postblit needed!
+    // D automatically calls the postblit for each HeapString field
     // when ValueEvaluation is blitted
-    this(this) @trusted nothrow @nogc {
-        // Nested postblits handle ref counting automatically
-    }
 }
 ```
 
@@ -203,40 +203,9 @@ static HeapData create(size_t initialCapacity = 0) @trusted @nogc nothrow {
 }
 ```
 
-## Assignment Operators
-
-HeapData provides both lvalue and rvalue assignment operators:
-
-### Lvalue Assignment (from another variable)
-
-```d
-void opAssign(ref HeapData rhs) @trusted @nogc nothrow {
-    // Handle self-assignment
-    if (isHeap() && rhs.isHeap() && _payload.heap is rhs._payload.heap) {
-        return;
-    }
-
-    // Decrement old ref count and free if needed
-    if (isHeap() && _payload.heap) {
-        if (--_payload.heap.refCount == 0) {
-            free(_payload.heap);
-        }
-    }
-
-    // Copy from rhs
-    _length = rhs._length;
-    _flags = rhs._flags;
+## Assignment Operator
 
-    if (rhs.isHeap()) {
-        _payload.heap = rhs._payload.heap;
-        if (_payload.heap) _payload.heap.refCount++;
-    } else {
-        _payload.small = rhs._payload.small;  // Copy SBO data
-    }
-}
-```
-
-### Rvalue Assignment (from temporary)
+HeapData provides a single assignment operator that handles both lvalue and rvalue assignments efficiently:
 
 ```d
 void opAssign(HeapData rhs) @trusted @nogc nothrow {
@@ -247,7 +216,7 @@ void opAssign(HeapData rhs) @trusted @nogc nothrow {
         }
     }
 
-    // Take ownership from rhs
+    // Take ownership from rhs (rhs was copied via postblit)
     _length = rhs._length;
     _flags = rhs._flags;
 
@@ -256,11 +225,13 @@ void opAssign(HeapData rhs) @trusted @nogc nothrow {
         rhs._payload.heap = null;  // Prevent rhs destructor from freeing
         rhs.setHeap(false);
     } else {
-        _payload.small = rhs._payload.small;
+        _payload.small = rhs._payload.small;  // Copy SBO data
     }
 }
 ```
 
+When called with an lvalue, D invokes the postblit constructor on `rhs` first, incrementing the ref count. The assignment then takes ownership of the copied reference. This unified approach keeps the code simpler while handling all cases correctly.
+
 ## Accessing HeapString Content
 
 Use the slice operator `[]` to get a `const(char)[]` from a HeapString:
@@ -319,6 +290,8 @@ assert(hs.isValid(), "HeapString memory corruption detected");
 
 With the current implementation, you **don't need to**:
 - Call `incrementRefCount()` before returning structs (postblit handles this)
+- Write explicit postblit or copy constructors for structs containing HeapString (D calls nested postblits automatically)
+- Write explicit assignment operators for structs containing HeapString (D handles this)
 - Worry about heap allocation for short strings (SBO handles this)
 - Make two allocations for ref count and data (combined allocation)
 - Manually track reference counts when passing structs through containers

operation-snapshots.md

@@ -54,94 +54,26 @@ struct ValueEvaluation {
   string[string] meta;
 
   /// The file name containing the evaluated value
-  string fileName;
+  HeapString fileName;
 
   /// The line number of the evaluated value
   size_t line;
 
   /// a custom text to be prepended to the value
-  string prependText;
-
-  /// Copy constructor
-  this(ref return scope ValueEvaluation other) @trusted nothrow {
-    this.throwable = other.throwable;
-    this.duration = other.duration;
-    this.gcMemoryUsed = other.gcMemoryUsed;
-    this.nonGCMemoryUsed = other.nonGCMemoryUsed;
-    this.strValue = other.strValue;
-    this.proxyValue = other.proxyValue;
-    this.niceValue = other.niceValue;
-    this.typeNames = other.typeNames;
-    this.meta = other.meta;
-    this.fileName = other.fileName;
-    this.line = other.line;
-    this.prependText = other.prependText;
-  }
-
-  /// Assignment operator (properly handles HeapString ref counting)
-  void opAssign(ref ValueEvaluation other) @trusted nothrow {
-    this.throwable = other.throwable;
-    this.duration = other.duration;
-    this.gcMemoryUsed = other.gcMemoryUsed;
-    this.nonGCMemoryUsed = other.nonGCMemoryUsed;
-    this.strValue = other.strValue;
-    this.proxyValue = other.proxyValue;
-    this.niceValue = other.niceValue;
-    this.typeNames = other.typeNames;
-    this.meta = other.meta;
-    this.fileName = other.fileName;
-    this.line = other.line;
-    this.prependText = other.prependText;
-  }
-
-  /// Assignment operator for rvalues
-  void opAssign(ValueEvaluation other) @trusted nothrow {
-    this.throwable = other.throwable;
-    this.duration = other.duration;
-    this.gcMemoryUsed = other.gcMemoryUsed;
-    this.nonGCMemoryUsed = other.nonGCMemoryUsed;
-    this.strValue = other.strValue;
-    this.proxyValue = other.proxyValue;
-    this.niceValue = other.niceValue;
-    this.typeNames = other.typeNames;
-    this.meta = other.meta;
-    this.fileName = other.fileName;
-    this.line = other.line;
-    this.prependText = other.prependText;
-  }
-
-  /// Postblit - called after D blits this struct.
-  /// HeapString members have their own postblit that increments ref counts.
-  /// This is called automatically by D when the struct is copied via blit.
-  this(this) @trusted nothrow @nogc {
-    // HeapString's postblit handles ref counting automatically
-    // No additional work needed here, but having an explicit postblit
-    // ensures the struct is properly marked as having postblit semantics
-  }
-
-  /// Increment HeapString ref counts to survive blit operations.
-  /// D's blit (memcpy) doesn't call copy constructors.
-  ///
-  /// IMPORTANT: Call this IMMEDIATELY before returning a ValueEvaluation
-  /// or any struct containing it from a function.
-  void prepareForBlit() @trusted nothrow @nogc {
-    strValue.incrementRefCount();
-    niceValue.incrementRefCount();
-  }
+  HeapString prependText;
+
+  // HeapString has proper postblit/opAssign, so D handles copying automatically
 
   /// Returns true if this ValueEvaluation's HeapString fields are valid.
-  /// Use this in debug assertions to catch memory corruption early.
   bool isValid() @trusted nothrow @nogc const {
     return strValue.isValid() && niceValue.isValid();
   }
 
   /// Returns the primary type name of the evaluated value.
-  /// Returns: The first type name, or "unknown" if no types are available.
   string typeName() @safe nothrow @nogc {
-    if(typeNames.length == 0) {
+    if (typeNames.length == 0) {
       return "unknown";
     }
-
     return typeNames[0];
   }
 }
@@ -153,74 +85,7 @@ struct Evaluation {
   /// The id of the current evaluation
   size_t id;
 
-  /// Copy constructor
-  this(ref return scope Evaluation other) @trusted nothrow {
-    this.id = other.id;
-    this.currentValue = other.currentValue;
-    this.expectedValue = other.expectedValue;
-    this._operationCount = other._operationCount;
-    foreach (i; 0 .. other._operationCount) {
-      this._operationNames[i] = other._operationNames[i];
-    }
-    this.isNegated = other.isNegated;
-    this.source = other.source;
-    this.throwable = other.throwable;
-    this.isEvaluated = other.isEvaluated;
-    this.result = other.result;
-  }
-
-  /// Assignment operator (properly handles HeapString ref counting)
-  void opAssign(ref Evaluation other) @trusted nothrow {
-    this.id = other.id;
-    this.currentValue = other.currentValue;
-    this.expectedValue = other.expectedValue;
-    this._operationCount = other._operationCount;
-    foreach (i; 0 .. other._operationCount) {
-      this._operationNames[i] = other._operationNames[i];
-    }
-    this.isNegated = other.isNegated;
-    this.source = other.source;
-    this.throwable = other.throwable;
-    this.isEvaluated = other.isEvaluated;
-    this.result = other.result;
-  }
-
-  /// Assignment operator for rvalues
-  void opAssign(Evaluation other) @trusted nothrow {
-    this.id = other.id;
-    this.currentValue = other.currentValue;
-    this.expectedValue = other.expectedValue;
-    this._operationCount = other._operationCount;
-    foreach (i; 0 .. other._operationCount) {
-      this._operationNames[i] = other._operationNames[i];
-    }
-    this.isNegated = other.isNegated;
-    this.source = other.source;
-    this.throwable = other.throwable;
-    this.isEvaluated = other.isEvaluated;
-    this.result = other.result;
-  }
-
-  /// Postblit - called after D blits this struct.
-  /// Nested structs with postblit (ValueEvaluation, HeapString) have
-  /// their postblits called automatically by D.
-  this(this) @trusted nothrow @nogc {
-    // Nested postblits handle ref counting automatically
-  }
-
-  /// Increment HeapString ref counts to survive blit operations.
-  /// D's blit (memcpy) doesn't call copy constructors.
-  ///
-  /// NOTE: With postblit constructors, this method may no longer be needed
-  /// in most cases. Keep it for backwards compatibility and edge cases.
-  void prepareForBlit() @trusted nothrow @nogc {
-    currentValue.prepareForBlit();
-    expectedValue.prepareForBlit();
-    foreach (i; 0 .. _operationCount) {
-      _operationNames[i].incrementRefCount();
-    }
-    result.prepareForBlit();
-  }
+  // HeapString has proper postblit/opAssign, so D handles copying automatically
 
   /// The value that will be validated
   ValueEvaluation currentValue;
@@ -409,12 +274,10 @@ auto evaluate(T)(lazy T testData, const string file = __FILE__, const size_t lin
     valueEvaluation.proxyValue = equableValue(value, niceValueStr);
     valueEvaluation.niceValue = toHeapString(niceValueStr);
     valueEvaluation.typeNames = extractTypes!TT;
-    valueEvaluation.fileName = file;
+    valueEvaluation.fileName = toHeapString(file);
     valueEvaluation.line = line;
-    valueEvaluation.prependText = prependText;
+    valueEvaluation.prependText = toHeapString(prependText);
 
-    // Increment HeapString ref counts to survive the blit on return
-    valueEvaluation.prepareForBlit();
     return Result(value, valueEvaluation);
   } catch(Throwable t) {
     T result;
@@ -435,12 +298,10 @@ auto evaluate(T)(lazy T testData, const string file = __FILE__, const size_t lin
     valueEvaluation.proxyValue = equableValue(result, resultStr);
     valueEvaluation.niceValue = toHeapString(resultStr);
     valueEvaluation.typeNames = extractTypes!T;
-    valueEvaluation.fileName = file;
+    valueEvaluation.fileName = toHeapString(file);
     valueEvaluation.line = line;
-    valueEvaluation.prependText = prependText;
+    valueEvaluation.prependText = toHeapString(prependText);
 
-    // Increment HeapString ref counts to survive the blit on return
-    valueEvaluation.prepareForBlit();
     return Result(result, valueEvaluation);
   }
 }

source/fluentasserts/core/evaluation.d

@@ -56,7 +56,7 @@ import std.conv;
   this(ValueEvaluation value) @trusted {
     _evaluation.id = Lifecycle.instance.beginEvaluation(value);
     _evaluation.currentValue = value;
-    _evaluation.source = SourceResult.create(value.fileName, value.line);
+    _evaluation.source = SourceResult.create(value.fileName[].idup, value.line);
 
     try {
       auto sourceValue = _evaluation.source.getValue;
@@ -72,8 +72,8 @@ import std.conv;
 
     _evaluation.result.addText(" should");
 
-    if(value.prependText) {
-      _evaluation.result.addText(value.prependText);
+    if(value.prependText.length > 0) {
+      _evaluation.result.addText(value.prependText[].idup);
     }
   }
 
@@ -530,13 +530,11 @@ Expect expect(void delegate() callable, const string file = __FILE__, const size
     value.meta["Throwable"] = "yes";
   }
 
-  value.fileName = file;
+  value.fileName = toHeapString(file);
   value.line = line;
-  value.prependText = prependText;
+  value.prependText = toHeapString(prependText);
 
   auto result = Expect(value);
-  // Increment HeapString ref counts to survive the blit on return.
-  result._evaluation.prepareForBlit();
   return result;
 }
 
@@ -549,9 +547,5 @@ Expect expect(void delegate() callable, const string file = __FILE__, const size
 /// Returns: An Expect struct for fluent assertions
 Expect expect(T)(lazy T testedValue, const string file = __FILE__, const size_t line = __LINE__, string prependText = null) @trusted {
   auto result = Expect(testedValue.evaluate(file, line, prependText).evaluation);
-  // Increment HeapString ref counts to survive the blit on return.
-  // D's blit (memcpy) doesn't call copy constructors, so we must manually
-  // ensure ref counts are incremented before the original is destroyed.
-  result._evaluation.prepareForBlit();
   return result;
 }

source/fluentasserts/core/expect.d

@@ -170,8 +170,6 @@ Evaluation recordEvaluation(void delegate() assertion) @trusted {
 
   assertion();
 
-  // Increment HeapString ref counts to survive the blit on return
-  Lifecycle.instance.lastEvaluation.prepareForBlit();
   return Lifecycle.instance.lastEvaluation;
 }
 

source/fluentasserts/core/lifecycle.d

@@ -85,12 +85,6 @@ struct AssertResult {
       || diff.length > 0 || extra.length > 0 || missing.length > 0;
   }
 
-  /// No-op for AssertResult (no HeapString fields).
-  /// Required for Evaluation.prepareForBlit() compatibility.
-  void prepareForBlit() @trusted nothrow @nogc {
-    // AssertResult uses FixedAppender, not HeapString, so nothing to do
-  }
-
   /// Formats a value for display, replacing special characters with glyphs.
   string formatValue(string value) nothrow inout {
     return value