🐛 JSON decode, ensure use of provided ArrayPool<byte>

andersstorhaug · andersstorhaug · commit 9e3c616acc00 · 2026-01-24T05:55:30.000-05:00
diff --git a/TronDotNet.SystemTextJson/TronJsonDecoder.cs b/TronDotNet.SystemTextJson/TronJsonDecoder.cs
@@ -111,7 +111,11 @@ public static async Task<DecodeResult> DecodeAsync(
         ArrayPool<byte>? arrayPool,
         CancellationToken cancellationToken)
     {
+        var growBuffer = arrayPool != null;
         var isRentedBuffer = false;
+        
+        arrayPool ??= ArrayPool<byte>.Shared;
+        
         if (buffer == null)
         {
             if (arrayPool == null)
@@ -151,9 +155,10 @@ public static async Task<DecodeResult> DecodeAsync(
                 var jsonReader = new Utf8JsonReader(readerBuffer, isCompleted, readerState);
                 
                 var status = DecodeCore(
+                    arrayPool,
                     ref frames,
                     ref buffer,
-                    arrayPool,
+                    growBuffer,
                     ref isRentedBuffer,
                     ref position,
                     ref jsonReader);
@@ -199,7 +204,11 @@ private static (byte[] Buffer, int Position) DecodeImpl(
         ReadOnlySpan<byte> utf8Json,
         ArrayPool<byte>? arrayPool)
     {
+        var growBuffer = arrayPool != null;
         var isRentedBuffer = false;
+        
+        arrayPool ??= ArrayPool<byte>.Shared;
+        
         if (buffer == null)
         {
             if (arrayPool == null)
@@ -215,10 +224,10 @@ private static (byte[] Buffer, int Position) DecodeImpl(
 
         do
         {
-            var status = DecodeCore(
+            var status = DecodeCore(arrayPool,
                 ref frames,
                 ref buffer,
-                arrayPool,
+                growBuffer,
                 ref isRentedBuffer,
                 ref position,
                 ref jsonReader);
@@ -234,9 +243,10 @@ private static (byte[] Buffer, int Position) DecodeImpl(
     }
     
     private static Lite3.Status DecodeCore(
+        ArrayPool<byte> arrayPool,
         ref FrameStack frames,
         ref byte[] buffer,
-        ArrayPool<byte>? arrayPool,
+        bool growBuffer,
         ref bool isRentedBuffer,
         ref int position,
         ref Utf8JsonReader reader)
@@ -252,16 +262,16 @@ private static Lite3.Status DecodeCore(
 
             var status = frame.Kind switch
             {
-                FrameKind.Object => DecodeObject(ref frames, replayToken, ref reader),
-                FrameKind.ObjectSwitch => DecodeObjectSwitch(ref frames, buffer, ref position, replayToken, ref reader),
-                FrameKind.Array => DecodeArray(ref frames, replayToken, ref reader),
-                FrameKind.ArraySwitch => DecodeArraySwitch(ref frames, buffer, ref position, ref reader),
+                FrameKind.Object => DecodeObject(arrayPool, ref frames, replayToken, ref reader),
+                FrameKind.ObjectSwitch => DecodeObjectSwitch(arrayPool, ref frames, buffer, ref position, replayToken, ref reader),
+                FrameKind.Array => DecodeArray(arrayPool, ref frames, replayToken, ref reader),
+                FrameKind.ArraySwitch => DecodeArraySwitch(arrayPool, ref frames, buffer, ref position, ref reader),
                 _ => throw new InvalidDataException("Unknown frame kind.")
             };
 
             replayToken = false;
 
-            if (status == Lite3.Status.InsufficientBuffer && arrayPool != null)
+            if (status == Lite3.Status.InsufficientBuffer && growBuffer)
             {
                 status = TronBuffer.Grow(arrayPool, isRentedBuffer, buffer, out buffer);
                 isRentedBuffer = true;
@@ -307,6 +317,7 @@ private static Lite3.Status DecodeDocument(
     }
     
     private static Lite3.Status DecodeObject(
+        ArrayPool<byte> arrayPool,
         ref FrameStack frames,
         bool replayToken,
         ref Utf8JsonReader reader)
@@ -323,21 +334,22 @@ private static Lite3.Status DecodeObject(
         {
             if (reader.TokenType == JsonTokenType.EndObject)
             {
-                frames.Pop();
+                frames.Pop(arrayPool);
                 return 0;
             }
 
             if (reader.TokenType != JsonTokenType.PropertyName)
                 return Lite3.Status.ExpectedJsonProperty;
 
-            frames.Push(Frame.ForObjectSwitch(offset, GetKeyRef(ref reader)));
+            frames.Push(Frame.ForObjectSwitch(offset, GetKeyRef(arrayPool, ref reader)));
             return 0;
         }
 
         return reader.IsFinalBlock ? Lite3.Status.InsufficientBuffer : Lite3.Status.NeedsMoreData;
     }
     
     private static Lite3.Status DecodeObjectSwitch(
+        ArrayPool<byte> arrayPool,
         ref FrameStack frames,
         byte[] buffer,
         ref int position,
@@ -377,17 +389,17 @@ private static Lite3.Status DecodeObjectSwitch(
             }
             case JsonTokenType.String:
             {
-                var value = ReadUtf8Value(ref reader, out var rentedBuffer);
+                var value = ReadUtf8Value(arrayPool, ref reader, out var rentedBuffer);
                 status = Lite3.SetString(buffer, ref position, offset, key, keyData, value);
                 if (rentedBuffer != null)
-                    ArrayPool<byte>.Shared.Return(rentedBuffer);
+                    arrayPool.Return(rentedBuffer);
                 break;
             }
             case JsonTokenType.StartObject:
             {
                 if ((status = Lite3.SetObject(buffer, ref position, offset, key, keyData, out var objectOffset)) >= 0)
                 {
-                    frames.Pop();
+                    frames.Pop(arrayPool);
                     frames.Push(Frame.ForObject(objectOffset));
                 }
 
@@ -397,7 +409,7 @@ private static Lite3.Status DecodeObjectSwitch(
             {
                 if ((status = Lite3.SetArray(buffer, ref position, offset, key, keyData, out var arrayOffset)) >= 0)
                 {
-                    frames.Pop();
+                    frames.Pop(arrayPool);
                     frames.Push(Frame.ForArray(arrayOffset));
                 }
 
@@ -411,12 +423,16 @@ private static Lite3.Status DecodeObjectSwitch(
         if (status < 0)
             return status;
         
-        frames.Pop();
+        frames.Pop(arrayPool);
         
         return status;
     }
     
-    private static Lite3.Status DecodeArray(ref FrameStack frames, bool replayToken, ref Utf8JsonReader reader)
+    private static Lite3.Status DecodeArray(
+        ArrayPool<byte> arrayPool,
+        ref FrameStack frames,
+        bool replayToken,
+        ref Utf8JsonReader reader)
     {
         if (reader.CurrentDepth > JsonConstants.NestingDepthMax)
             return Lite3.Status.JsonNestingDepthExceededMax;
@@ -430,7 +446,7 @@ private static Lite3.Status DecodeArray(ref FrameStack frames, bool replayToken,
         {
             if (reader.TokenType == JsonTokenType.EndArray)
             {
-                frames.Pop();
+                frames.Pop(arrayPool);
                 return 0;
             }
 
@@ -442,6 +458,7 @@ private static Lite3.Status DecodeArray(ref FrameStack frames, bool replayToken,
     }
     
     private static Lite3.Status DecodeArraySwitch(
+        ArrayPool<byte> arrayPool,
         ref FrameStack frames,
         byte[] buffer,
         ref int position,
@@ -474,17 +491,17 @@ private static Lite3.Status DecodeArraySwitch(
             }
             case JsonTokenType.String:
             {
-                var value = ReadUtf8Value(ref reader, out var rentedBuffer);
+                var value = ReadUtf8Value(arrayPool, ref reader, out var rentedBuffer);
                 status = Lite3.ArrayAppendString(buffer, ref position, offset, value);
                 if (rentedBuffer != null)
-                    ArrayPool<byte>.Shared.Return(rentedBuffer);
+                    arrayPool.Return(rentedBuffer);
                 break;
             }
             case JsonTokenType.StartObject:
             {
                 if ((status = Lite3.ArrayAppendObject(buffer, ref position, offset, out var objectOffset)) >= 0)
                 {
-                    frames.Pop();
+                    frames.Pop(arrayPool);
                     frames.Push(Frame.ForObject(objectOffset));
                 }
 
@@ -494,7 +511,7 @@ private static Lite3.Status DecodeArraySwitch(
             {
                 if ((status = Lite3.ArrayAppendArray(buffer, ref position, offset, out var arrayOffset)) >= 0)
                 {
-                    frames.Pop();
+                    frames.Pop(arrayPool);
                     frames.Push(Frame.ForArray(arrayOffset));
                 }
 
@@ -505,12 +522,12 @@ private static Lite3.Status DecodeArraySwitch(
                 break;
         }
         
-        frames.Pop();
+        frames.Pop(arrayPool);
 
         return status;
     }
 
-    private static KeyRef GetKeyRef(ref Utf8JsonReader reader)
+    private static KeyRef GetKeyRef(ArrayPool<byte> arrayPool, ref Utf8JsonReader reader)
     {
         var length = reader.HasValueSequence
             ? checked((int)reader.ValueSequence.Length)
@@ -530,7 +547,7 @@ private static KeyRef GetKeyRef(ref Utf8JsonReader reader)
             };
         }
         
-        var pooledKey = ArrayPool<byte>.Shared.Rent(length);
+        var pooledKey = arrayPool.Rent(length);
         
         length = reader.CopyString(pooledKey);
 
@@ -543,15 +560,18 @@ private static KeyRef GetKeyRef(ref Utf8JsonReader reader)
     }
     
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private static ReadOnlySpan<byte> ReadUtf8Value(ref Utf8JsonReader reader, out byte[]? rented)
+    private static ReadOnlySpan<byte> ReadUtf8Value(
+        ArrayPool<byte> arrayPool,
+        ref Utf8JsonReader reader,
+        out byte[]? rented)
     {
         if (reader.HasValueSequence || reader.ValueIsEscaped)
         {
             var length = reader.HasValueSequence
                 ? checked((int)reader.ValueSequence.Length)
                 : reader.ValueSpan.Length;
             
-            rented = ArrayPool<byte>.Shared.Rent(length);
+            rented = arrayPool.Rent(length);
             length = reader.CopyString(rented);
             
             return rented.AsSpan(0, length);
@@ -582,12 +602,12 @@ public Lite3.Status Push(in Frame frame)
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void Pop()
+        public void Pop(ArrayPool<byte> arrayPool)
         {
             ref var frame = ref _frames[_index];
             
             if (frame is { Kind: FrameKind.ObjectSwitch })
-                frame.KeyRef.Return();
+                frame.KeyRef.Return(arrayPool);
 
             _frames[_index--] = default;
         }
@@ -643,10 +663,10 @@ private struct KeyRef
         };
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void Return()
+        public void Return(ArrayPool<byte> arrayPool)
         {
             if (Kind == KeyRefKind.Pooled && PooledKey != null)
-                ArrayPool<byte>.Shared.Return(PooledKey);
+                arrayPool.Return(PooledKey);
         }
     }
 

Original file line number	Diff line number	Diff line change
`@@ -111,7 +111,11 @@ public static async Task<DecodeResult> DecodeAsync(`
`111`	`111`	`ArrayPool<byte>? arrayPool,`
`112`	`112`	`CancellationToken cancellationToken)`
`113`	`113`	`{`
	`114`	`+ var growBuffer = arrayPool != null;`
`114`	`115`	`var isRentedBuffer = false;`
	`116`	`+`
	`117`	`+ arrayPool ??= ArrayPool<byte>.Shared;`
	`118`	`+`
`115`	`119`	`if (buffer == null)`
`116`	`120`	`{`
`117`	`121`	`if (arrayPool == null)`
`@@ -151,9 +155,10 @@ public static async Task<DecodeResult> DecodeAsync(`
`151`	`155`	`var jsonReader = new Utf8JsonReader(readerBuffer, isCompleted, readerState);`
`152`	`156`
`153`	`157`	`var status = DecodeCore(`
	`158`	`+ arrayPool,`
`154`	`159`	`ref frames,`
`155`	`160`	`ref buffer,`
`156`		`- arrayPool,`
	`161`	`+ growBuffer,`
`157`	`162`	`ref isRentedBuffer,`
`158`	`163`	`ref position,`
`159`	`164`	`ref jsonReader);`
`@@ -199,7 +204,11 @@ private static (byte[] Buffer, int Position) DecodeImpl(`
`199`	`204`	`ReadOnlySpan<byte> utf8Json,`
`200`	`205`	`ArrayPool<byte>? arrayPool)`
`201`	`206`	`{`
	`207`	`+ var growBuffer = arrayPool != null;`
`202`	`208`	`var isRentedBuffer = false;`
	`209`	`+`
	`210`	`+ arrayPool ??= ArrayPool<byte>.Shared;`
	`211`	`+`
`203`	`212`	`if (buffer == null)`
`204`	`213`	`{`
`205`	`214`	`if (arrayPool == null)`
`@@ -215,10 +224,10 @@ private static (byte[] Buffer, int Position) DecodeImpl(`
`215`	`224`
`216`	`225`	`do`
`217`	`226`	`{`
`218`		`- var status = DecodeCore(`
	`227`	`+ var status = DecodeCore(arrayPool,`
`219`	`228`	`ref frames,`
`220`	`229`	`ref buffer,`
`221`		`- arrayPool,`
	`230`	`+ growBuffer,`
`222`	`231`	`ref isRentedBuffer,`
`223`	`232`	`ref position,`
`224`	`233`	`ref jsonReader);`
`@@ -234,9 +243,10 @@ private static (byte[] Buffer, int Position) DecodeImpl(`
`234`	`243`	`}`
`235`	`244`
`236`	`245`	`private static Lite3.Status DecodeCore(`
	`246`	`+ ArrayPool<byte> arrayPool,`
`237`	`247`	`ref FrameStack frames,`
`238`	`248`	`ref byte[] buffer,`
`239`		`- ArrayPool<byte>? arrayPool,`
	`249`	`+ bool growBuffer,`
`240`	`250`	`ref bool isRentedBuffer,`
`241`	`251`	`ref int position,`
`242`	`252`	`ref Utf8JsonReader reader)`
`@@ -252,16 +262,16 @@ private static Lite3.Status DecodeCore(`
`252`	`262`
`253`	`263`	`var status = frame.Kind switch`
`254`	`264`	`{`
`255`		`- FrameKind.Object => DecodeObject(ref frames, replayToken, ref reader),`
`256`		`- FrameKind.ObjectSwitch => DecodeObjectSwitch(ref frames, buffer, ref position, replayToken, ref reader),`
`257`		`- FrameKind.Array => DecodeArray(ref frames, replayToken, ref reader),`
`258`		`- FrameKind.ArraySwitch => DecodeArraySwitch(ref frames, buffer, ref position, ref reader),`
	`265`	`+ FrameKind.Object => DecodeObject(arrayPool, ref frames, replayToken, ref reader),`
	`266`	`+ FrameKind.ObjectSwitch => DecodeObjectSwitch(arrayPool, ref frames, buffer, ref position, replayToken, ref reader),`
	`267`	`+ FrameKind.Array => DecodeArray(arrayPool, ref frames, replayToken, ref reader),`
	`268`	`+ FrameKind.ArraySwitch => DecodeArraySwitch(arrayPool, ref frames, buffer, ref position, ref reader),`
`259`	`269`	`_ => throw new InvalidDataException("Unknown frame kind.")`
`260`	`270`	`};`
`261`	`271`
`262`	`272`	`replayToken = false;`
`263`	`273`
`264`		`- if (status == Lite3.Status.InsufficientBuffer && arrayPool != null)`
	`274`	`+ if (status == Lite3.Status.InsufficientBuffer && growBuffer)`
`265`	`275`	`{`
`266`	`276`	`status = TronBuffer.Grow(arrayPool, isRentedBuffer, buffer, out buffer);`
`267`	`277`	`isRentedBuffer = true;`
`@@ -307,6 +317,7 @@ private static Lite3.Status DecodeDocument(`
`307`	`317`	`}`
`308`	`318`
`309`	`319`	`private static Lite3.Status DecodeObject(`
	`320`	`+ ArrayPool<byte> arrayPool,`
`310`	`321`	`ref FrameStack frames,`
`311`	`322`	`bool replayToken,`
`312`	`323`	`ref Utf8JsonReader reader)`
`@@ -323,21 +334,22 @@ private static Lite3.Status DecodeObject(`
`323`	`334`	`{`
`324`	`335`	`if (reader.TokenType == JsonTokenType.EndObject)`
`325`	`336`	`{`
`326`		`- frames.Pop();`
	`337`	`+ frames.Pop(arrayPool);`
`327`	`338`	`return 0;`
`328`	`339`	`}`
`329`	`340`
`330`	`341`	`if (reader.TokenType != JsonTokenType.PropertyName)`
`331`	`342`	`return Lite3.Status.ExpectedJsonProperty;`
`332`	`343`
`333`		`- frames.Push(Frame.ForObjectSwitch(offset, GetKeyRef(ref reader)));`
	`344`	`+ frames.Push(Frame.ForObjectSwitch(offset, GetKeyRef(arrayPool, ref reader)));`
`334`	`345`	`return 0;`
`335`	`346`	`}`
`336`	`347`
`337`	`348`	`return reader.IsFinalBlock ? Lite3.Status.InsufficientBuffer : Lite3.Status.NeedsMoreData;`
`338`	`349`	`}`
`339`	`350`
`340`	`351`	`private static Lite3.Status DecodeObjectSwitch(`
	`352`	`+ ArrayPool<byte> arrayPool,`
`341`	`353`	`ref FrameStack frames,`
`342`	`354`	`byte[] buffer,`
`343`	`355`	`ref int position,`
`@@ -377,17 +389,17 @@ private static Lite3.Status DecodeObjectSwitch(`
`377`	`389`	`}`
`378`	`390`	`case JsonTokenType.String:`
`379`	`391`	`{`
`380`		`- var value = ReadUtf8Value(ref reader, out var rentedBuffer);`
	`392`	`+ var value = ReadUtf8Value(arrayPool, ref reader, out var rentedBuffer);`
`381`	`393`	`status = Lite3.SetString(buffer, ref position, offset, key, keyData, value);`
`382`	`394`	`if (rentedBuffer != null)`
`383`		`- ArrayPool<byte>.Shared.Return(rentedBuffer);`
	`395`	`+ arrayPool.Return(rentedBuffer);`
`384`	`396`	`break;`
`385`	`397`	`}`
`386`	`398`	`case JsonTokenType.StartObject:`
`387`	`399`	`{`
`388`	`400`	`if ((status = Lite3.SetObject(buffer, ref position, offset, key, keyData, out var objectOffset)) >= 0)`
`389`	`401`	`{`
`390`		`- frames.Pop();`
	`402`	`+ frames.Pop(arrayPool);`
`391`	`403`	`frames.Push(Frame.ForObject(objectOffset));`
`392`	`404`	`}`
`393`	`405`
`@@ -397,7 +409,7 @@ private static Lite3.Status DecodeObjectSwitch(`
`397`	`409`	`{`
`398`	`410`	`if ((status = Lite3.SetArray(buffer, ref position, offset, key, keyData, out var arrayOffset)) >= 0)`
`399`	`411`	`{`
`400`		`- frames.Pop();`
	`412`	`+ frames.Pop(arrayPool);`
`401`	`413`	`frames.Push(Frame.ForArray(arrayOffset));`
`402`	`414`	`}`
`403`	`415`
`@@ -411,12 +423,16 @@ private static Lite3.Status DecodeObjectSwitch(`
`411`	`423`	`if (status < 0)`
`412`	`424`	`return status;`
`413`	`425`
`414`		`- frames.Pop();`
	`426`	`+ frames.Pop(arrayPool);`
`415`	`427`
`416`	`428`	`return status;`
`417`	`429`	`}`
`418`	`430`
`419`		`- private static Lite3.Status DecodeArray(ref FrameStack frames, bool replayToken, ref Utf8JsonReader reader)`
	`431`	`+ private static Lite3.Status DecodeArray(`
	`432`	`+ ArrayPool<byte> arrayPool,`
	`433`	`+ ref FrameStack frames,`
	`434`	`+ bool replayToken,`
	`435`	`+ ref Utf8JsonReader reader)`
`420`	`436`	`{`
`421`	`437`	`if (reader.CurrentDepth > JsonConstants.NestingDepthMax)`
`422`	`438`	`return Lite3.Status.JsonNestingDepthExceededMax;`
`@@ -430,7 +446,7 @@ private static Lite3.Status DecodeArray(ref FrameStack frames, bool replayToken,`
`430`	`446`	`{`
`431`	`447`	`if (reader.TokenType == JsonTokenType.EndArray)`
`432`	`448`	`{`
`433`		`- frames.Pop();`
	`449`	`+ frames.Pop(arrayPool);`
`434`	`450`	`return 0;`
`435`	`451`	`}`
`436`	`452`
`@@ -442,6 +458,7 @@ private static Lite3.Status DecodeArray(ref FrameStack frames, bool replayToken,`
`442`	`458`	`}`
`443`	`459`
`444`	`460`	`private static Lite3.Status DecodeArraySwitch(`
	`461`	`+ ArrayPool<byte> arrayPool,`
`445`	`462`	`ref FrameStack frames,`
`446`	`463`	`byte[] buffer,`
`447`	`464`	`ref int position,`
`@@ -474,17 +491,17 @@ private static Lite3.Status DecodeArraySwitch(`
`474`	`491`	`}`
`475`	`492`	`case JsonTokenType.String:`
`476`	`493`	`{`
`477`		`- var value = ReadUtf8Value(ref reader, out var rentedBuffer);`
	`494`	`+ var value = ReadUtf8Value(arrayPool, ref reader, out var rentedBuffer);`
`478`	`495`	`status = Lite3.ArrayAppendString(buffer, ref position, offset, value);`
`479`	`496`	`if (rentedBuffer != null)`
`480`		`- ArrayPool<byte>.Shared.Return(rentedBuffer);`
	`497`	`+ arrayPool.Return(rentedBuffer);`
`481`	`498`	`break;`
`482`	`499`	`}`
`483`	`500`	`case JsonTokenType.StartObject:`
`484`	`501`	`{`
`485`	`502`	`if ((status = Lite3.ArrayAppendObject(buffer, ref position, offset, out var objectOffset)) >= 0)`
`486`	`503`	`{`
`487`		`- frames.Pop();`
	`504`	`+ frames.Pop(arrayPool);`
`488`	`505`	`frames.Push(Frame.ForObject(objectOffset));`
`489`	`506`	`}`
`490`	`507`
`@@ -494,7 +511,7 @@ private static Lite3.Status DecodeArraySwitch(`
`494`	`511`	`{`
`495`	`512`	`if ((status = Lite3.ArrayAppendArray(buffer, ref position, offset, out var arrayOffset)) >= 0)`
`496`	`513`	`{`
`497`		`- frames.Pop();`
	`514`	`+ frames.Pop(arrayPool);`
`498`	`515`	`frames.Push(Frame.ForArray(arrayOffset));`
`499`	`516`	`}`
`500`	`517`
`@@ -505,12 +522,12 @@ private static Lite3.Status DecodeArraySwitch(`
`505`	`522`	`break;`
`506`	`523`	`}`
`507`	`524`
`508`		`- frames.Pop();`
	`525`	`+ frames.Pop(arrayPool);`
`509`	`526`
`510`	`527`	`return status;`
`511`	`528`	`}`
`512`	`529`
`513`		`- private static KeyRef GetKeyRef(ref Utf8JsonReader reader)`
	`530`	`+ private static KeyRef GetKeyRef(ArrayPool<byte> arrayPool, ref Utf8JsonReader reader)`
`514`	`531`	`{`
`515`	`532`	`var length = reader.HasValueSequence`
`516`	`533`	`? checked((int)reader.ValueSequence.Length)`
`@@ -530,7 +547,7 @@ private static KeyRef GetKeyRef(ref Utf8JsonReader reader)`
`530`	`547`	`};`
`531`	`548`	`}`
`532`	`549`
`533`		`- var pooledKey = ArrayPool<byte>.Shared.Rent(length);`
	`550`	`+ var pooledKey = arrayPool.Rent(length);`
`534`	`551`
`535`	`552`	`length = reader.CopyString(pooledKey);`
`536`	`553`
`@@ -543,15 +560,18 @@ private static KeyRef GetKeyRef(ref Utf8JsonReader reader)`
`543`	`560`	`}`
`544`	`561`
`545`	`562`	`[MethodImpl(MethodImplOptions.AggressiveInlining)]`
`546`		`- private static ReadOnlySpan<byte> ReadUtf8Value(ref Utf8JsonReader reader, out byte[]? rented)`
	`563`	`+ private static ReadOnlySpan<byte> ReadUtf8Value(`
	`564`	`+ ArrayPool<byte> arrayPool,`
	`565`	`+ ref Utf8JsonReader reader,`
	`566`	`+ out byte[]? rented)`
`547`	`567`	`{`
`548`	`568`	`if (reader.HasValueSequence \|\| reader.ValueIsEscaped)`
`549`	`569`	`{`
`550`	`570`	`var length = reader.HasValueSequence`
`551`	`571`	`? checked((int)reader.ValueSequence.Length)`
`552`	`572`	`: reader.ValueSpan.Length;`
`553`	`573`
`554`		`- rented = ArrayPool<byte>.Shared.Rent(length);`
	`574`	`+ rented = arrayPool.Rent(length);`
`555`	`575`	`length = reader.CopyString(rented);`
`556`	`576`
`557`	`577`	`return rented.AsSpan(0, length);`
`@@ -582,12 +602,12 @@ public Lite3.Status Push(in Frame frame)`
`582`	`602`	`}`
`583`	`603`
`584`	`604`	`[MethodImpl(MethodImplOptions.AggressiveInlining)]`
`585`		`- public void Pop()`
	`605`	`+ public void Pop(ArrayPool<byte> arrayPool)`
`586`	`606`	`{`
`587`	`607`	`ref var frame = ref _frames[_index];`
`588`	`608`
`589`	`609`	`if (frame is { Kind: FrameKind.ObjectSwitch })`
`590`		`- frame.KeyRef.Return();`
	`610`	`+ frame.KeyRef.Return(arrayPool);`
`591`	`611`
`592`	`612`	`_frames[_index--] = default;`
`593`	`613`	`}`
`@@ -643,10 +663,10 @@ private struct KeyRef`
`643`	`663`	`};`
`644`	`664`
`645`	`665`	`[MethodImpl(MethodImplOptions.AggressiveInlining)]`
`646`		`- public void Return()`
	`666`	`+ public void Return(ArrayPool<byte> arrayPool)`
`647`	`667`	`{`
`648`	`668`	`if (Kind == KeyRefKind.Pooled && PooledKey != null)`
`649`		`- ArrayPool<byte>.Shared.Return(PooledKey);`
	`669`	`+ arrayPool.Return(PooledKey);`
`650`	`670`	`}`
`651`	`671`	`}`
`652`	`672`