Fix MoveTo when moving to the same destination (#12898)

<!--Ex. Fixing a bug - Describe the bug and how this fixes the issue.
Ex. Adding a feature - Explain what this achieves.-->
#### Description

Moving the data between same source and destination causes the
destination to be cleared.

<!-- Issue number if applicable -->
#### Link to tracking issue
Fixes #12887

Signed-off-by: Bogdan Drutu <[email protected]>

Author: bogdandrutu

.chloggen/fix-moveto.yaml

@@ -0,0 +1,25 @@
+# Use this changelog template to create an entry for release notes.
+
+# One of 'breaking', 'deprecation', 'new_component', 'enhancement', 'bug_fix'
+change_type: bug_fix
+
+# The name of the component, or a single word describing the area of concern, (e.g. otlpreceiver)
+component: pdata
+
+# A brief description of the change.  Surround your text with quotes ("") if it needs to start with a backtick (`).
+note: Fix MoveTo when moving to the same destination
+
+# One or more tracking issues or pull requests related to the change
+issues: [12887]
+
+# (Optional) One or more lines of additional information to render under the primary note.
+# These lines will be padded with 2 spaces and then inserted directly into the document.
+# Use pipe (|) for multiline entries.
+subtext:
+
+# Optional: The change log or logs in which this entry should be included.
+# e.g. '[user]' or '[user, api]'
+# Include 'user' if the change is relevant to end users.
+# Include 'api' if there is a change to a library API.
+# Default: '[user]'
+change_logs: [api]

pdata/internal/cmd/pdatagen/internal/templates/message.go.tmpl

@@ -50,6 +50,10 @@ func New{{ .structName }}() {{ .structName }} {
 func (ms {{ .structName }}) MoveTo(dest {{ .structName }}) {
 	ms.{{ .stateAccessor }}.AssertMutable()
 	dest.{{ .stateAccessor }}.AssertMutable()
+	// If they point to the same data, they are the same, nothing to do.
+	if ms.{{ .origAccessor }} == dest.{{ .origAccessor }} {
+		return
+	}
 	*dest.{{ .origAccessor }} = *ms.{{ .origAccessor }}
 	*ms.{{ .origAccessor }} = {{ .originName }}{}
 }

pdata/internal/cmd/pdatagen/internal/templates/message_test.go.tmpl

@@ -18,6 +18,8 @@ func Test{{ .structName }}_MoveTo(t *testing.T) {
 	ms.MoveTo(dest)
 	assert.Equal(t, New{{ .structName }}(), ms)
 	assert.Equal(t, generateTest{{ .structName }}(), dest)
+	dest.MoveTo(dest)
+	assert.Equal(t, generateTest{{ .structName }}(), dest)
 	sharedState := internal.StateReadOnly
 	assert.Panics(t, func() { ms.MoveTo(new{{ .structName }}(&{{ .originName }}{}, &sharedState)) })
 	assert.Panics(t, func() { new{{ .structName }}(&{{ .originName }}{}, &sharedState).MoveTo(dest) })

pdata/internal/cmd/pdatagen/internal/templates/primitive_slice.go.tmpl

@@ -105,6 +105,10 @@ func (ms {{ .structName }}) Append(elms ...{{ .itemType }}) {
 func (ms {{ .structName }}) MoveTo(dest {{ .structName }}) {
 	ms.getState().AssertMutable()
 	dest.getState().AssertMutable()
+	// If they point to the same data, they are the same, nothing to do.
+	if ms.getOrig() == dest.getOrig() {
+		return
+	}
 	*dest.getOrig() = *ms.getOrig()
 	*ms.getOrig() = nil
 }

pdata/internal/cmd/pdatagen/internal/templates/primitive_slice_test.go.tmpl

@@ -65,6 +65,13 @@ func TestNew{{ .structName }}(t *testing.T) {
 	{{- else }}
 	assert.Equal(t, {{ .itemType }}({{index .testInterfaceOrigVal 0 }}), mv.At(0))
 	{{- end }}
+	mv.MoveTo(mv)
+	assert.Equal(t, 3, mv.Len())
+	{{- if eq .itemType "float64" }}
+	assert.InDelta(t, {{ .itemType }}({{index .testInterfaceOrigVal 0 }}), mv.At(0), 0.01)
+	{{- else }}
+	assert.Equal(t, {{ .itemType }}({{index .testInterfaceOrigVal 0 }}), mv.At(0))
+	{{- end }}
 }
 
 func Test{{ .structName }}ReadOnly(t *testing.T) {

pdata/internal/cmd/pdatagen/internal/templates/slice.go.tmpl

@@ -113,6 +113,10 @@ func (es {{ .structName }}) AppendEmpty() {{ .elementName }} {
 func (es {{ .structName }}) MoveAndAppendTo(dest {{ .structName }}) {
 	es.{{ .stateAccessor }}.AssertMutable()
 	dest.{{ .stateAccessor }}.AssertMutable()
+	// If they point to the same data, they are the same, nothing to do.
+	if es.{{ .origAccessor }} == dest.{{ .origAccessor }} {
+		return
+	}
 	if *dest.{{ .origAccessor }} == nil {
 		// We can simply move the entire vector and avoid any allocations.
 		*dest.{{ .origAccessor }} = *es.{{ .origAccessor }}

pdata/internal/cmd/pdatagen/internal/templates/slice_test.go.tmpl

@@ -107,6 +107,13 @@ func Test{{ .structName }}_MoveAndAppendTo(t *testing.T) {
 		assert.Equal(t, expectedSlice.At(i), dest.At(i))
 		assert.Equal(t, expectedSlice.At(i), dest.At(i+expectedSlice.Len()))
 	}
+
+	dest.MoveAndAppendTo(dest)
+	assert.Equal(t, 2*expectedSlice.Len(), dest.Len())
+	for i := 0; i < expectedSlice.Len(); i++ {
+		assert.Equal(t, expectedSlice.At(i), dest.At(i))
+		assert.Equal(t, expectedSlice.At(i), dest.At(i+expectedSlice.Len()))
+	}
 }
 
 func Test{{ .structName }}_RemoveIf(t *testing.T) {

pdata/pcommon/generated_byteslice.go

@@ -248,6 +248,10 @@ func (m Map) All() iter.Seq2[string, Value] {
 func (m Map) MoveTo(dest Map) {
 	m.getState().AssertMutable()
 	dest.getState().AssertMutable()
+	// If they point to the same data, they are the same, nothing to do.
+	if m.getOrig() == dest.getOrig() {
+		return
+	}
 	*dest.getOrig() = *m.getOrig()
 	*m.getOrig() = nil
 }

pdata/pcommon/generated_byteslice_test.go

@@ -416,6 +416,11 @@ func TestMap_MoveTo(t *testing.T) {
 	// Test MoveTo from empty to non-empty
 	NewMap().MoveTo(dest)
 	assert.Equal(t, 0, dest.Len())
+
+	dest.PutStr("k", "v")
+	dest.MoveTo(dest)
+	assert.Equal(t, 1, dest.Len())
+	assert.Equal(t, map[string]any{"k": "v"}, dest.AsRaw())
 }
 
 func TestMap_CopyTo(t *testing.T) {

pdata/pcommon/generated_float64slice.go

@@ -42,6 +42,10 @@ func (ms TraceState) FromRaw(v string) {
 func (ms TraceState) MoveTo(dest TraceState) {
 	ms.getState().AssertMutable()
 	dest.getState().AssertMutable()
+	// If they point to the same data, they are the same, nothing to do.
+	if ms.getOrig() == dest.getOrig() {
+		return
+	}
 	*dest.getOrig() = *ms.getOrig()
 	*ms.getOrig() = ""
 }

pdata/pcommon/generated_float64slice_test.go

@@ -17,6 +17,9 @@ func TestTraceState_MoveTo(t *testing.T) {
 	ms.MoveTo(dest)
 	assert.Equal(t, NewTraceState(), ms)
 	assert.Equal(t, TraceState(internal.GenerateTestTraceState()), dest)
+
+	dest.MoveTo(dest)
+	assert.Equal(t, TraceState(internal.GenerateTestTraceState()), dest)
 }
 
 func TestTraceState_CopyTo(t *testing.T) {

pdata/pcommon/generated_instrumentationscope.go

@@ -324,6 +324,10 @@ func (v Value) SetEmptySlice() Slice {
 func (v Value) MoveTo(dest Value) {
 	v.getState().AssertMutable()
 	dest.getState().AssertMutable()
+	// If they point to the same data, they are the same, nothing to do.
+	if v.getOrig() == dest.getOrig() {
+		return
+	}
 	*dest.getOrig() = *v.getOrig()
 	v.getOrig().Value = nil
 }

pdata/pcommon/generated_instrumentationscope_test.go

@@ -244,6 +244,9 @@ func TestValue_MoveTo(t *testing.T) {
 	expected := NewValueMap()
 	expected.Map().PutStr("key", "value")
 	assert.True(t, dest.Equal(expected))
+
+	dest.MoveTo(dest)
+	assert.True(t, dest.Equal(expected))
 }
 
 func TestValue_CopyTo(t *testing.T) {