fix: resolve buffer not been cleared (#1590)

<!--
Important: Before developing new features, please open an issue to
discuss your ideas with the maintainers. This ensures project alignment
and helps avoid unnecessary work for you.

Thank you for your contribution! Please provide a detailed description
below and ensure you've met all the requirements.

Squashed commit messages must follow the [Conventional
Commits](https://www.conventionalcommits.org/en/v1.0.0/) standard to
facilitate changelog generation.

Please ensure your PR title follows the Conventional Commits
specification, using the appropriate type (e.g., feat, fix, docs) and
scope.

Examples of good PR titles:

- 💥feat!: change implementation in an non-backward compatible way
- ✨feat(auth): add support for OAuth2 login
- 🐞fix(router): add support for custom metrics
- 📚docs(README): update installation instructions
- 🧹chore(deps): bump dependencies to latest versions
-->

This PR resolves the following issue, where the buffer does not seem to
be cleared

<img width="983" height="468" alt="image"
src="https://github.com/user-attachments/assets/331e473e-75fd-41c3-8fa5-8b2a52b8501f"
/>

@coderabbitai summary

## Checklist

- [ ] I have discussed my proposed changes in an issue and have received
approval to proceed.
- [ ] I have followed the coding standards of the project.
- [ ] Tests or benchmarks have been added or updated.

## Open Source AI Manifesto

This project follows the principles of the [Open Source AI
Manifesto](https://human-oss.dev). Please ensure your contribution
aligns with its principles.

<!--
Please add any additional information or context regarding your changes
here.
-->

Author: SkArchon

v2/pkg/astnormalization/inline_arguments.go

@@ -97,7 +97,7 @@ func (v *inlineArgumentsVisitor) EnterArgument(ref int) {
 	}
 
 	finding := InlineArgument{
-		ArgumentName: v.operation.ArgumentNameString(ref),
+		ArgumentName: string(v.operation.ArgumentNameBytes(ref)),
 		ValueKind:    valueKind,
 		Position:     v.operation.Arguments[ref].Position,
 		Path:         v.Path.DotDelimitedString(),
@@ -107,9 +107,9 @@ func (v *inlineArgumentsVisitor) EnterArgument(ref int) {
 	finding.AncestorKind = parent.Kind
 	switch parent.Kind {
 	case ast.NodeKindField:
-		finding.AncestorName = v.operation.FieldNameString(parent.Ref)
+		finding.AncestorName = string(v.operation.FieldNameBytes(parent.Ref))
 	case ast.NodeKindDirective:
-		finding.AncestorName = v.operation.DirectiveNameString(parent.Ref)
+		finding.AncestorName = string(v.operation.DirectiveNameBytes(parent.Ref))
 	}
 
 	v.result.InlineArguments = append(v.result.InlineArguments, finding)

v2/pkg/astnormalization/inline_arguments_test.go

@@ -269,6 +269,46 @@ func TestInlineArgumentsRule_Enforce(t *testing.T) {
 	})
 }
 
+func TestInlineArgumentsRule_FindingOwnsItsBytes(t *testing.T) {
+	definitionDocument := unsafeparser.ParseGraphqlDocumentString(inlineArgumentsTestSchema)
+	require.NoError(t, asttransform.MergeDefinitionWithBaseSchema(&definitionDocument))
+
+	operationDocument := unsafeparser.ParseGraphqlDocumentString(`query GetField { field(obj: { a: 1 }) @include(if: true) }`)
+	report := &operationreport.Report{}
+
+	normalizer := NewWithOpts(WithInlineArgumentsValidation(InlineArgumentsValidationOptions{Enforce: false}))
+	result := normalizer.NormalizeNamedOperationWithResult(&operationDocument, &definitionDocument, nil, report, RunOptions{})
+
+	require.False(t, report.HasErrors())
+	require.Len(t, result.InlineArguments, 2)
+
+	fieldArg := result.InlineArguments[0]
+	require.Equal(t, "obj", fieldArg.ArgumentName)
+	require.Equal(t, "field", fieldArg.AncestorName)
+	require.Equal(t, ast.NodeKindField, fieldArg.AncestorKind)
+
+	directiveArg := result.InlineArguments[1]
+	require.Equal(t, "if", directiveArg.ArgumentName)
+	require.Equal(t, "include", directiveArg.AncestorName)
+	require.Equal(t, ast.NodeKindDirective, directiveArg.AncestorKind)
+
+	// Simulate the operation document being recycled from the pool: scribble over
+	// its input buffer. A finding that owns its bytes is unaffected; one that
+	// aliases the input buffer is corrupted.
+	for i := range operationDocument.Input.RawBytes {
+		operationDocument.Input.RawBytes[i] = 'x'
+	}
+
+	assert.Equal(t, "obj", result.InlineArguments[0].ArgumentName,
+		"field ArgumentName must own its bytes, not alias the operation input buffer")
+	assert.Equal(t, "field", result.InlineArguments[0].AncestorName,
+		"field AncestorName must own its bytes, not alias the operation input buffer")
+	assert.Equal(t, "if", result.InlineArguments[1].ArgumentName,
+		"directive ArgumentName must own its bytes, not alias the operation input buffer")
+	assert.Equal(t, "include", result.InlineArguments[1].AncestorName,
+		"directive AncestorName must own its bytes, not alias the operation input buffer")
+}
+
 func TestInlineArgumentsRule_OptionOffReturnsNil(t *testing.T) {
 	definitionDocument := unsafeparser.ParseGraphqlDocumentString(inlineArgumentsTestSchema)
 	require.NoError(t, asttransform.MergeDefinitionWithBaseSchema(&definitionDocument))