Unexpected behavior when comparing slices of maps

[Yi-Liang-Leon]

version: go-cmp@v0.7.0, go@v1.21.3
When I was comparing slices of maps defined as:

a := []any{map[string]any{"a": 1, "b": 2, "c": 3}}
b := []any{map[string]any{"a": 2, "b": 4, "c": 3}}
fmt.Println(cmp.Diff(a,b))

The result is:

[]any{
    map[string]any{
-       "a": int(1)
-       "a": int(2)
-       "b": int(2)
-       "b": int(4)
        "c": int(3)
    },
}

Which means it traversed inside the map entries.

However, when I was doing this:

a := []any{map[string]any{"a": 1, "b": 2, "c": 3}}
b := []any{map[string]any{"a": 2, "b": 4, "c": 6}}
fmt.Println(cmp.Diff(a,b))

The result become:

[]any{
-    map[string]any{"a": int(1), "b": int(2), "c": int(3)},
+    map[string]any{"a": int(2), "b": int(4), "c": int(6)},
}

I've tested several tests, and it seems that it stops traversing only when the map have three or more differences. Is it a bug, or am I doing anything wrong? Since I'm using go-cmp to handle deserialized objects, this case will affect the path filter.

[dsnet]

The difference reporter in cmp is a somewhat complex set of heuristics that tries to produce a diff that is generally best at representing the difference. The particular heuristic you are observing is that it choses to treat the entire upper layer as different if enough differences are observed at the lower levels.

This particular example doesn't seem to indicate that the heuristic is doing poorly. Literally every element in the map is different.

[Yi-Liang-Leon]

Thank you for your explanation. Is there a way to bypass the heuristics and make sure the entire search tree is traversed?

Also, I realized that go-cmp treats these two maps as:

-  {[]any}[0->?]: xxx
+ {[]any}[?->0]: xxx

rather than

-  {[]any}[0]: xxx
+ {[]any}[0]: xxx

This behavior is sometimes confusing as well. Sometimes, the two slice elements are logically the same (e.g. has the same "name" field), but considered totally different. Is there some ways to customize the matching rules of SliceIndex objects?

P.S: Sorry for the misleading example I provided. I've made a new attempt and here's the result:

a := []any{map[string]any{"a": 1, "b": 2, "c": 3, "d": 4}}
b := []any{map[string]any{"a": 2, "b": 4, "c": 6, "d": 4}}
fmt.Println(cmp.Diff(a,b))
---
[]any{
-    map[string]any{"a": int(1), "b": int(2), "c": int(3), "d": int(4)},
+    map[string]any{"a": int(2), "b": int(4), "c": int(6), "d": int(4)},
}

In this case, not all elements are different, but the reporter still stopped at the upper level.