Ensure the relevant interfaces are implemented on the TensorSpan and ReadOnlyTensorSpan types

Author: tannergooding

src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/IReadOnlyTensor.cs

@@ -56,9 +56,5 @@ public interface IReadOnlyTensor
         /// <summary>Gets the stride of each dimension in the tensor.</summary>
         [UnscopedRef]
         ReadOnlySpan<nint> Strides { get; }
-
-        /// <summary>Pins and gets a <see cref="MemoryHandle"/> to the backing memory.</summary>
-        /// <returns><see cref="MemoryHandle"/></returns>
-        MemoryHandle GetPinnedHandle();
     }
 }

src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/IReadOnlyTensor_1.cs

@@ -2,16 +2,18 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System.Buffers;
-using System.Collections.Generic;
-using System.Diagnostics.CodeAnalysis;
 
 namespace System.Numerics.Tensors
 {
     /// <summary>Represents a read-only tensor.</summary>
     /// <typeparam name="TSelf">The type that implements this interface.</typeparam>
     /// <typeparam name="T">The element type.</typeparam>
-    public interface IReadOnlyTensor<TSelf, T> : IReadOnlyTensor, IEnumerable<T>
+    public interface IReadOnlyTensor<TSelf, T> : IReadOnlyTensor
+#if NET9_0_OR_GREATER
+        where TSelf : IReadOnlyTensor<TSelf, T>, allows ref struct
+#else
         where TSelf : IReadOnlyTensor<TSelf, T>
+#endif
     {
         /// <summary>Gets an empty tensor.</summary>
         static abstract TSelf Empty { get; }

src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/ITensor_1.cs

@@ -2,15 +2,18 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System.Buffers;
-using System.Diagnostics.CodeAnalysis;
 
 namespace System.Numerics.Tensors
 {
     /// <summary>Represents a tensor.</summary>
     /// <typeparam name="TSelf">The type that implements this interface.</typeparam>
     /// <typeparam name="T">The element type.</typeparam>
     public interface ITensor<TSelf, T> : ITensor, IReadOnlyTensor<TSelf, T>
+#if NET9_0_OR_GREATER
+        where TSelf : ITensor<TSelf, T>, allows ref struct
+#else
         where TSelf : ITensor<TSelf, T>
+#endif
     {
         // TODO: Determine if we can implement `IEqualityOperators<TSelf, T, bool>`.
         // It looks like C#/.NET currently hits limitations here as it believes TSelf and T could be the same type

src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/ReadOnlyTensorDimensionSpan_1.cs

@@ -1,10 +1,12 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System.Runtime.CompilerServices;
+
+#if NET9_0_OR_GREATER
 using System.Collections;
 using System.Collections.Generic;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
+#endif
 
 namespace System.Numerics.Tensors
 {
@@ -28,9 +30,12 @@ internal ReadOnlyTensorDimensionSpan(ReadOnlyTensorSpan<T> tensor, int dimension
             _tensor = tensor;
             _length = TensorPrimitives.Product(tensor.Lengths[..dimension]);
             _dimension = dimension;
-            _sliceShape = TensorShape.Create((dimension != tensor.Rank) ? tensor.Lengths[dimension..] : [1], tensor.Strides[dimension..]);
+            _sliceShape = TensorShape.Create((dimension != tensor.Rank) ? tensor.Lengths[dimension..] : [1], tensor.Strides[dimension..], tensor.IsPinned);
         }
 
+        /// <summary>Gets <c>true</c> if the slices that exist within the tracked dimension are dense; otherwise, <c>false</c>.</summary>
+        public bool IsDense => _sliceShape.IsDense;
+
         /// <summary>Gets the length of the tensor dimension span.</summary>
         public nint Length => _length;
 

src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/ReadOnlyTensorSpan_1.cs

@@ -22,6 +22,9 @@ namespace System.Numerics.Tensors
     [DebuggerTypeProxy(typeof(TensorSpanDebugView<>))]
     [DebuggerDisplay("{ToString(),raw}")]
     public readonly ref struct ReadOnlyTensorSpan<T>
+#if NET9_0_OR_GREATER
+        : IReadOnlyTensor<ReadOnlyTensorSpan<T>, T>
+#endif
     {
         /// <inheritdoc cref="IReadOnlyTensor{TSelf, T}.Empty" />
         public static ReadOnlyTensorSpan<T> Empty => default;
@@ -54,12 +57,7 @@ public ReadOnlyTensorSpan(T[]? array)
         ///   * <paramref name="lengths" /> is not empty and has a flattened length greater than <paramref name="array" />.Length.
         /// </exception>
         public ReadOnlyTensorSpan(T[]? array, scoped ReadOnlySpan<nint> lengths)
-        {
-            _shape = TensorShape.Create(array, lengths);
-            _reference = ref (array is not null)
-                       ? ref MemoryMarshal.GetArrayDataReference(array)
-                       : ref Unsafe.NullRef<T>();
-        }
+            : this(array, lengths, strides: []) { }
 
         /// <summary>Creates a new tensor over the portion of the target array beginning at the specified start index and using the specified lengths and strides.</summary>
         /// <param name="array">The target array.</param>
@@ -113,7 +111,7 @@ public ReadOnlyTensorSpan(T[]? array, int start, scoped ReadOnlySpan<nint> lengt
         public ReadOnlyTensorSpan(ReadOnlySpan<T> span)
         {
             ref T reference = ref MemoryMarshal.GetReference(span);
-            _shape = TensorShape.Create(ref reference, span.Length);
+            _shape = TensorShape.Create(ref reference, span.Length, pinned: false);
             _reference = ref reference;
         }
 
@@ -126,11 +124,7 @@ public ReadOnlyTensorSpan(ReadOnlySpan<T> span)
         ///   * <paramref name="lengths" /> is not empty and has a flattened length greater than <paramref name="span" />.Length.
         /// </exception>
         public ReadOnlyTensorSpan(ReadOnlySpan<T> span, scoped ReadOnlySpan<nint> lengths)
-        {
-            ref T reference = ref MemoryMarshal.GetReference(span);
-            _shape = TensorShape.Create(ref reference, span.Length, lengths);
-            _reference = ref reference;
-        }
+            : this(span, lengths, strides: []) { }
 
         /// <summary>Creates a new tensor span over the target span using the specified lengths and strides.</summary>
         /// <param name="span">The target span.</param>
@@ -147,7 +141,7 @@ public ReadOnlyTensorSpan(ReadOnlySpan<T> span, scoped ReadOnlySpan<nint> length
         public ReadOnlyTensorSpan(ReadOnlySpan<T> span, scoped ReadOnlySpan<nint> lengths, scoped ReadOnlySpan<nint> strides)
         {
             ref T reference = ref MemoryMarshal.GetReference(span);
-            _shape = TensorShape.Create(ref reference, span.Length, lengths, strides);
+            _shape = TensorShape.Create(ref reference, span.Length, lengths, strides, pinned: false);
             _reference = ref reference;
         }
 
@@ -219,10 +213,7 @@ public unsafe ReadOnlyTensorSpan(T* data, nint dataLength)
         /// </exception>
         [CLSCompliant(false)]
         public unsafe ReadOnlyTensorSpan(T* data, nint dataLength, scoped ReadOnlySpan<nint> lengths)
-        {
-            _shape = TensorShape.Create(data, dataLength, lengths);
-            _reference = ref Unsafe.AsRef<T>(data);
-        }
+            : this(data, dataLength, lengths, strides: []) { }
 
         /// <summary>Creates a new tensor span over the target unmanaged buffer using the specified lengths and strides.</summary>
         /// <param name="data">The pointer to the start of the target unmanaged buffer.</param>
@@ -247,28 +238,9 @@ public unsafe ReadOnlyTensorSpan(T* data, nint dataLength, scoped ReadOnlySpan<n
             _reference = ref Unsafe.AsRef<T>(data);
         }
 
-        // Constructor for internal use only. It is not safe to expose publicly.
-        internal ReadOnlyTensorSpan(ref T data, nint dataLength)
-        {
-            _shape = TensorShape.Create(ref data, dataLength);
-            _reference = ref data;
-        }
-
-        internal ReadOnlyTensorSpan(ref T data, nint dataLength, scoped ReadOnlySpan<nint> lengths)
-        {
-            _shape = TensorShape.Create(ref data, dataLength, lengths);
-            _reference = ref data;
-        }
-
-        internal ReadOnlyTensorSpan(ref T data, nint dataLength, scoped ReadOnlySpan<nint> lengths, scoped ReadOnlySpan<nint> strides)
+        internal ReadOnlyTensorSpan(ref T data, nint dataLength, scoped ReadOnlySpan<nint> lengths, scoped ReadOnlySpan<nint> strides, bool pinned)
         {
-            _shape = TensorShape.Create(ref data, dataLength, lengths, strides);
-            _reference = ref data;
-        }
-
-        internal ReadOnlyTensorSpan(ref T data, nint dataLength, scoped ReadOnlySpan<nint> lengths, scoped ReadOnlySpan<nint> strides, scoped ReadOnlySpan<int> linearRankOrder)
-        {
-            _shape = TensorShape.Create(ref data, dataLength, lengths, strides, linearRankOrder);
+            _shape = TensorShape.Create(ref data, dataLength, lengths, strides, pinned);
             _reference = ref data;
         }
 
@@ -308,6 +280,9 @@ public ReadOnlyTensorSpan<T> this[params scoped ReadOnlySpan<NRange> ranges]
         /// <inheritdoc cref="IReadOnlyTensor.IsEmpty" />
         public bool IsEmpty => _shape.IsEmpty;
 
+        /// <inheritdoc cref="IReadOnlyTensor.IsPinned" />
+        public bool IsPinned => _shape.IsPinned;
+
         /// <inheritdoc cref="IReadOnlyTensor.Lengths" />
         [UnscopedRef]
         public ReadOnlySpan<nint> Lengths => _shape.Lengths;
@@ -463,11 +438,47 @@ public bool TryFlattenTo(scoped Span<T> destination)
             return false;
         }
 
+#if NET9_0_OR_GREATER
+        //
+        // IReadOnlyTensor
+        //
+
+        object? IReadOnlyTensor.this[params scoped ReadOnlySpan<NIndex> indexes] => this[indexes];
+
+        object? IReadOnlyTensor.this[params scoped ReadOnlySpan<nint> indexes] => this[indexes];
+
+        //
+        // IReadOnlyTensor<TSelf, T>
+        //
+
+        ReadOnlyTensorSpan<T> IReadOnlyTensor<ReadOnlyTensorSpan<T>, T>.AsReadOnlyTensorSpan() => this;
+
+        ReadOnlyTensorSpan<T> IReadOnlyTensor<ReadOnlyTensorSpan<T>, T>.AsReadOnlyTensorSpan(params scoped ReadOnlySpan<nint> startIndexes) => Slice(startIndexes);
+
+        ReadOnlyTensorSpan<T> IReadOnlyTensor<ReadOnlyTensorSpan<T>, T>.AsReadOnlyTensorSpan(params scoped ReadOnlySpan<NIndex> startIndexes) => Slice(startIndexes);
+
+        ReadOnlyTensorSpan<T> IReadOnlyTensor<ReadOnlyTensorSpan<T>, T>.AsReadOnlyTensorSpan(params scoped ReadOnlySpan<NRange> ranges) => Slice(ranges);
+
+        ReadOnlyTensorSpan<T> IReadOnlyTensor<ReadOnlyTensorSpan<T>, T>.ToDenseTensor()
+        {
+            ReadOnlyTensorSpan<T> result = this;
+
+            if (!IsDense)
+            {
+                Tensor<T> tmp = Tensor.Create<T>(Lengths, IsPinned);
+                CopyTo(tmp);
+                result = tmp;
+            }
+
+            return result;
+        }
+#endif
+
         /// <summary>Enumerates the elements of a tensor span.</summary>
         public ref struct Enumerator : IEnumerator<T>
         {
             private readonly ReadOnlyTensorSpan<T> _span;
-            private nint[] _indexes;
+            private readonly nint[] _indexes;
             private nint _linearOffset;
             private nint _itemsEnumerated;
 
@@ -513,7 +524,7 @@ public void Reset()
             // IDisposable
             //
 
-            void IDisposable.Dispose() { }
+            readonly void IDisposable.Dispose() { }
 
             //
             // IEnumerator