cty: Use WrangleMarksDeep for UnmarkDeep and UnmarkDeepWithPaths

These functions were previously using the "Transformer" mechanism, which is
very general but as a result ends up always conservatively rebuilding
the entire data structure it's given.

The recently-added WrangleMarksDeep relies on the fact that it can only
possibly change marks (not the actual values) to avoid building a new
value at all in the common case where there are no marks, to rebuild
only the parts of the structure that have mark changes when changes are
being made, and to reuse the internal "payload" values from the source
values while just wrapping them in a new outer cty.Value.

Testing with a benchmark in another codebase that makes heavy use of both
UnmarkDeep and UnmarkDeepWithPaths shows this being a material performance
improvement.

This also includes a bonus fast path for MarkWithPaths where it will skip
doing anything at all if the given slice of ParkValueMarks is empty.

Author: apparentlymart

CHANGELOG.md

@@ -12,6 +12,8 @@
 
 - `cty.ValueMarksOfType` and `cty.ValueMarksOfTypeDeep` make it easier to use type-based rather than value-based mark schemes, where different values of a common type are used to track a specific kind of relationship with multiple external values.
 - `cty.Value.HasMarkDeep` provides a "deep" version of the existing `cty.Value.HasMark`, searching throughout a possibly-nested structure for any values that have the given mark.
+- `cty.Value.UnmarkDeep` and `cty.Value.UnmarkDeepWithPaths` are now implemented in terms of `cty.Value.WrangleMarksDeep`, so they benefit from its reduced overhead. In particular they avoid reconstructing a data structure that contains no marks at all.
+- `cty.Value.MarkWithPaths` now has a fast path when it's given a zero-length `PathValueMarks`, in which case it just returns the value it was given with no modifications.
 
 # 1.16.4 (August 20, 2025)
 

cty/marks.go

@@ -4,6 +4,8 @@ import (
 	"fmt"
 	"iter"
 	"strings"
+
+	"github.com/zclconf/go-cty/cty/ctymarks"
 )
 
 // marker is an internal wrapper type used to add special "marks" to values.
@@ -284,6 +286,11 @@ func (t *applyPathValueMarksTransformer) Exit(p Path, v Value) (Value, error) {
 // markers to particular paths and returns the marked
 // Value.
 func (val Value) MarkWithPaths(pvm []PathValueMarks) Value {
+	if len(pvm) == 0 {
+		// If we have no marks to apply then there's nothing to do, so we'll
+		// just return the same value rather than wastefully rebuilding it.
+		return val
+	}
 	ret, _ := TransformWithTransformer(val, &applyPathValueMarksTransformer{pvm})
 	return ret
 }
@@ -305,52 +312,44 @@ func (val Value) Unmark() (Value, ValueMarks) {
 	}, marks
 }
 
-type unmarkTransformer struct {
-	pvm []PathValueMarks
-}
-
-func (t *unmarkTransformer) Enter(p Path, v Value) (Value, error) {
-	unmarkedVal, marks := v.Unmark()
-	if len(marks) > 0 {
-		path := make(Path, len(p), len(p)+1)
-		copy(path, p)
-		t.pvm = append(t.pvm, PathValueMarks{path, marks})
-	}
-	return unmarkedVal, nil
-}
-
-func (t *unmarkTransformer) Exit(p Path, v Value) (Value, error) {
-	return v, nil
-}
-
 // UnmarkDeep is similar to Unmark, but it works with an entire nested structure
 // rather than just the given value directly.
 //
 // The result is guaranteed to contain no nested values that are marked, and
 // the returned marks set includes the superset of all of the marks encountered
 // during the operation.
 func (val Value) UnmarkDeep() (Value, ValueMarks) {
-	t := unmarkTransformer{}
-	ret, _ := TransformWithTransformer(val, &t)
-
-	marks := make(ValueMarks)
-	for _, pvm := range t.pvm {
-		for m, s := range pvm.Marks {
-			marks[m] = s
-		}
-	}
-
-	return ret, marks
+	retMarks := make(ValueMarks)
+	retVal, _ := val.WrangleMarksDeep(func(mark any, path Path) (ctymarks.WrangleAction, error) {
+		retMarks[mark] = struct{}{}
+		return ctymarks.WrangleDrop, nil
+	})
+	return retVal, retMarks
 }
 
 // UnmarkDeepWithPaths is like UnmarkDeep, except it returns a slice
 // of PathValueMarks rather than a superset of all marks. This allows
 // a caller to know which marks are associated with which paths
 // in the Value.
 func (val Value) UnmarkDeepWithPaths() (Value, []PathValueMarks) {
-	t := unmarkTransformer{}
-	ret, _ := TransformWithTransformer(val, &t)
-	return ret, t.pvm
+	var pvm []PathValueMarks
+	retVal, _ := val.WrangleMarksDeep(func(mark any, path Path) (ctymarks.WrangleAction, error) {
+		if len(pvm) != 0 {
+			// We'll try to modify the most recent item instead of adding
+			// a new one, if the path hasn't changed.
+			latest := &pvm[len(pvm)-1]
+			if latest.Path.Equals(path) {
+				latest.Marks[mark] = struct{}{}
+				return ctymarks.WrangleDrop, nil
+			}
+		}
+		pvm = append(pvm, PathValueMarks{
+			Path:  path.Copy(),
+			Marks: NewValueMarks(mark),
+		})
+		return ctymarks.WrangleDrop, nil
+	})
+	return retVal, pvm
 }
 
 func (val Value) unmarkForce() Value {