Change Pin to take an optional integer offset

src/Common/src/CoreLib/System/Buffers/MemoryHandle.cs

@@ -41,24 +41,6 @@ public unsafe struct MemoryHandle : IDisposable
         /// </summary>
         public bool HasPointer => _pointer != null;
 
-        /// <summary>
-        /// Adds an offset to the pinned pointer.
-        /// </summary>
-        /// <exception cref="System.ArgumentNullException">
-        /// Throw when pinned pointer is null.
-        /// </exception>
-        internal void AddOffset(int offset)
-        {
-            if (_pointer == null)
-            {
-                ThrowHelper.ThrowArgumentNullException(ExceptionArgument.pointer);
-            }
-            else
-            {
-                _pointer = (void*)((byte*)_pointer + offset);
-            }
-        }
-
         /// <summary>
         /// Frees the pinned handle and releases IRetainable.
         /// </summary>

src/Common/src/CoreLib/System/Buffers/OwnedMemory.cs

@@ -43,7 +43,7 @@ public Memory<T> Memory
         /// <summary>
         /// Returns a handle for the array that has been pinned and hence its address can be taken
         /// </summary>
-        public abstract MemoryHandle Pin();
+        public abstract MemoryHandle Pin(int offset = 0);
 
         /// <summary>
         /// Returns an array segment.

src/Common/src/CoreLib/System/Memory.cs

@@ -244,8 +244,7 @@ public unsafe MemoryHandle Retain(bool pin = false)
             {
                 if (_index < 0)
                 {
-                    memoryHandle = ((OwnedMemory<T>)_object).Pin();
-                    memoryHandle.AddOffset((_index & RemoveOwnedFlagBitMask) * Unsafe.SizeOf<T>());
+                    memoryHandle = ((OwnedMemory<T>)_object).Pin((_index & RemoveOwnedFlagBitMask) * Unsafe.SizeOf<T>());
                 }
                 else if (typeof(T) == typeof(char) && _object is string s)
                 {

src/Common/src/CoreLib/System/ReadOnlyMemory.cs

@@ -222,8 +222,7 @@ public unsafe MemoryHandle Retain(bool pin = false)
             {
                 if (_index < 0)
                 {
-                    memoryHandle = ((OwnedMemory<T>)_object).Pin();
-                    memoryHandle.AddOffset((_index & RemoveOwnedFlagBitMask) * Unsafe.SizeOf<T>());
+                    memoryHandle = ((OwnedMemory<T>)_object).Pin((_index & RemoveOwnedFlagBitMask) * Unsafe.SizeOf<T>());
                 }
                 else if (typeof(T) == typeof(char) && _object is string s)
                 {

src/Common/tests/System/Buffers/NativeOwnedMemory.cs

@@ -53,7 +53,12 @@ protected override bool IsRetained
 
         public override unsafe Span<byte> Span => new Span<byte>((void*)_ptr, _length);
 
-        public override unsafe MemoryHandle Pin() => new MemoryHandle(this, (void*)_ptr);
+        public override unsafe MemoryHandle Pin(int offset = 0)
+        {
+            if (offset < 0 || offset > _length) throw new ArgumentOutOfRangeException(nameof(offset));
+            void* pointer = (void*)((byte*)_ptr + offset);
+            return new MemoryHandle(this, pointer);
+        }
 
         public override bool Release()
         {

src/System.Memory/ref/System.Memory.cs

@@ -225,7 +225,7 @@ protected OwnedMemory() { }
         public abstract System.Span<T> Span { get; }
         public void Dispose() { }
         protected abstract void Dispose(bool disposing);
-        public abstract System.Buffers.MemoryHandle Pin();
+        public abstract System.Buffers.MemoryHandle Pin(int offset=0);
         public abstract bool Release();
         public abstract void Retain();
         protected internal abstract bool TryGetArray(out System.ArraySegment<T> arraySegment);

src/System.Memory/tests/Memory/CustomMemoryForTest.cs

@@ -3,6 +3,7 @@
 // See the LICENSE file in the project root for more information.
 
 using System.Buffers;
+using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using System.Threading;
 
@@ -38,13 +39,14 @@ public override Span<T> Span
             }
         }
 
-        public override MemoryHandle Pin()
+        public override MemoryHandle Pin(int offset = 0)
         {
             unsafe
             {
                 Retain();
+                if (offset < 0 || offset > _array.Length) throw new ArgumentOutOfRangeException(nameof(offset));
                 var handle = GCHandle.Alloc(_array, GCHandleType.Pinned);
-                return new MemoryHandle(this, (void*)handle.AddrOfPinnedObject(), handle);
+                return new MemoryHandle(this, Unsafe.Add<byte>((void*)handle.AddrOfPinnedObject(), offset), handle);
             }
         }
 

src/System.Memory/tests/Memory/OwnedMemory.cs

@@ -86,6 +86,36 @@ public static void OwnedMemoryDispose()
             owner.Dispose();
             Assert.True(owner.IsDisposed);
         }
+
+        [Fact]
+        public static void OwnedMemoryPinEmptyArray()
+        {
+            int[] a = {};
+            OwnedMemory<int> owner = new CustomMemoryForTest<int>(a);
+            MemoryHandle handle = owner.Pin();
+            Assert.True(handle.HasPointer);
+        }
+
+        [Fact]
+        public static void OwnedMemoryPinArray()
+        {
+            int[] array = { 1, 2, 3, 4, 5 };
+            OwnedMemory<int> owner = new CustomMemoryForTest<int>(array);
+            MemoryHandle handle = owner.Pin();
+            Assert.True(handle.HasPointer);
+            unsafe
+            {
+                int* pointer = (int*)handle.Pointer;
+
+                GC.Collect();
+
+                for (int i = 0; i < owner.Memory.Length; i++)
+                {
+                    Assert.Equal(array[i], pointer[i]);
+                }
+            }
+            handle.Dispose();
+        }
 
         [Fact]
         public static void MemoryFromOwnedMemoryAfterDispose()

src/System.Memory/tests/Memory/Retain.cs

@@ -110,6 +110,23 @@ public static void OwnedMemoryRetainWithPinning()
             handle.Dispose();
         }
 
+        [Fact]
+        public static void MemoryFromEmptyArrayRetainWithPinning()
+        {
+            Memory<int> memory = new int[0];
+            MemoryHandle handle = memory.Retain(pin: true);
+            Assert.True(handle.HasPointer);
+            unsafe
+            {
+                int* pointer = (int*)handle.Pointer;
+
+                GC.Collect();
+
+                Assert.True(pointer != null);
+            }
+            handle.Dispose();
+        }
+
         [Fact]
         public static void OwnedMemoryRetainWithPinningAndSlice()
         {

src/System.Memory/tests/ReadOnlyMemory/Retain.cs

@@ -45,6 +45,23 @@ public static void MemoryRetainWithPinning()
             handle.Dispose();
         }
 
+        [Fact]
+        public static void MemoryFromEmptyArrayRetainWithPinning()
+        {
+            ReadOnlyMemory<int> memory = new int[0];
+            MemoryHandle handle = memory.Retain(pin: true);
+            Assert.True(handle.HasPointer);
+            unsafe
+            {
+                int* pointer = (int*)handle.Pointer;
+
+                GC.Collect();
+
+                Assert.True(pointer != null);
+            }
+            handle.Dispose();
+        }
+
         [Fact]
         public static void MemoryRetainWithPinningAndSlice()
         {

src/System.Runtime/ref/System.Runtime.cs

@@ -3728,7 +3728,7 @@ protected OwnedMemory() { }
         public abstract System.Span<T> Span { get; }
         public void Dispose() { }
         protected abstract void Dispose(bool disposing);
-        public abstract System.Buffers.MemoryHandle Pin();
+        public abstract MemoryHandle Pin(int offset=0);
         public abstract bool Release();
         public abstract void Retain();
         protected internal abstract bool TryGetArray(out System.ArraySegment<T> arraySegment);