perf(config): skip cloning the discarded side of a list-setting merge

mergeAny deep-cloned the earlier side of a list-typed settings leaf
via toAnySlice before checking whether the rule's merge mode was
Append or the default Replace, discarding that clone on the (common)
Replace path. It then made a second independent copy of the later
side, which toAnySlice had already cloned into a fresh backing array.
Check the merge mode first, only clone earlier when Append actually
needs it, and return the already-independent later clone directly on
Replace.

Ref docs/development/high-performance-go.md "Skip work you don't need".

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_016Y1J29TYsYdQrUeMxSAbox

Author: claude

internal/config/deepmerge.go

@@ -55,26 +55,49 @@ func mergeSettingsMap(ruleName string, earlier, later map[string]any) map[string
 // mergeAny merges later onto earlier for a single settings leaf or
 // nested value. Maps recurse, lists honor the rule's declared merge
 // mode, and everything else is replaced wholesale by later.
+//
+// The default merge mode (rule.MergeReplace) is by far the common
+// case — MergeAppend is an opt-in a rule declares via
+// rule.ListMerger. toAnySlice(earlier) fully deep-clones the earlier
+// side, so it is only called when settingMergeMode says the clone
+// will actually be used (the append branch); the replace branch
+// returns later's clone (ll) directly instead of copying it a second
+// time — toAnySlice already gives every case (`[]any`, `[]string`,
+// `[]int`) a fresh, independent backing array, so a second copy adds
+// nothing. See docs/development/high-performance-go.md "Skip work
+// you don't need".
 func mergeAny(ruleName, key string, earlier, later any) any {
 	if em, ok := earlier.(map[string]any); ok {
 		if lm, ok := later.(map[string]any); ok {
 			return mergeSettingsMap(ruleName, em, lm)
 		}
 	}
-	if el, ok := toAnySlice(earlier); ok {
+	if isAnySliceType(earlier) {
 		if ll, ok := toAnySlice(later); ok {
 			if settingMergeMode(ruleName, key) == rule.MergeAppend {
+				el, _ := toAnySlice(earlier)
 				merged := make([]any, 0, len(el)+len(ll))
 				merged = append(merged, el...)
 				merged = append(merged, ll...)
 				return merged
 			}
-			return append([]any(nil), ll...)
+			return ll
 		}
 	}
 	return cloneAny(later)
 }
 
+// isAnySliceType reports whether v is one of the slice types
+// toAnySlice normalizes, without cloning it. Mirrors toAnySlice's
+// type switch exactly.
+func isAnySliceType(v any) bool {
+	switch v.(type) {
+	case []any, []string, []int:
+		return true
+	}
+	return false
+}
+
 // settingMergeMode returns the merge mode for a list-typed rule
 // setting, defaulting to rule.MergeReplace when the rule does not
 // implement rule.ListMerger or is not registered.

internal/config/deepmerge_test.go

@@ -62,6 +62,29 @@ func TestMergeRuleCfgListReplacedByDefault(t *testing.T) {
 	assert.Equal(t, []any{"c"}, got.Settings["exclude"], "list defaults to replace")
 }
 
+// TestMergeAny_ListReplace_AllocBudget pins mergeAny's per-call
+// allocation count for the common list-replace path (a rule's list
+// setting with no ListMerger opt-in). mergeAny used to deep-clone the
+// discarded `earlier` side via toAnySlice even though the default
+// replace mode never uses it, and then made a second independent copy
+// of the already-independent `later` clone before returning it. See
+// docs/development/high-performance-go.md "Skip work you don't need".
+// This runs once per list-typed settings leaf present on both layers
+// being merged, on every config-signature cache miss.
+func TestMergeAny_ListReplace_AllocBudget(t *testing.T) {
+	earlier := []any{"a", "b", "c"}
+	later := []any{"d", "e"}
+	allocs := testing.AllocsPerRun(200, func() {
+		got := mergeAny("line-length", "exclude", earlier, later)
+		if len(got.([]any)) != 2 {
+			t.Fatalf("unexpected result: %v", got)
+		}
+	})
+	if allocs > 3 {
+		t.Fatalf("mergeAny (replace mode) allocs per call: want <= 3, got %v", allocs)
+	}
+}
+
 func TestMergeRuleCfgListAppendedWhenRuleOptsIn(t *testing.T) {
 	earlier := RuleCfg{
 		Enabled:  true,