Merge branch 'add-span' into generics-wip

Author: josesimoes

Tests/NFUnitTestTypes/UnitTestsSpanByte.cs

@@ -13,67 +13,67 @@ public class UnitTestsSpanByte
         public void EmptySpanTests()
         {
             // Empty span
-            SpanByte span = SpanByte.Empty;
+            Span span = Span.Empty;
             // Create a destination span larger
-            SpanByte destination = new byte[1];
+            Span destination = new byte[1];
             span.CopyTo(destination);
 
             // Now also empty
-            destination = SpanByte.Empty;
+            destination = Span.Empty;
             span.CopyTo(destination);
         }
 
         [TestMethod]
         public void RaisingExceptionsOfAllKindsTests()
         {
             // Should raise an exception on creation
-            Assert.ThrowsException(typeof(ArgumentOutOfRangeException), () => { SpanByte span = new SpanByte(null, 1, 2); }, "ArgumentOutOfRangeException when array is null, start is 1 and length is 2");
-            Assert.ThrowsException(typeof(ArgumentOutOfRangeException), () => { SpanByte span = new SpanByte(new byte[1], 1, 2); }, "ArgumentOutOfRangeException when array is new byte[1], start is 1 and length is 2");
-            Assert.ThrowsException(typeof(ArgumentOutOfRangeException), () => { SpanByte span = new SpanByte(new byte[1], 0, 2); }, "ArgumentOutOfRangeException when array is new byte[1], start is 0 and length is 2");
-            Assert.ThrowsException(typeof(ArgumentOutOfRangeException), () => { SpanByte span = new SpanByte(new byte[1], 2, 0); }, "ArgumentOutOfRangeException when array is new byte[1], start is 2 and length is 0");
+            Assert.ThrowsException(typeof(ArgumentOutOfRangeException), () => { Span span = new Span(null, 1, 2); }, "ArgumentOutOfRangeException when array is null, start is 1 and length is 2");
+            Assert.ThrowsException(typeof(ArgumentOutOfRangeException), () => { Span span = new Span(new byte[1], 1, 2); }, "ArgumentOutOfRangeException when array is new byte[1], start is 1 and length is 2");
+            Assert.ThrowsException(typeof(ArgumentOutOfRangeException), () => { Span span = new Span(new byte[1], 0, 2); }, "ArgumentOutOfRangeException when array is new byte[1], start is 0 and length is 2");
+            Assert.ThrowsException(typeof(ArgumentOutOfRangeException), () => { Span span = new Span(new byte[1], 2, 0); }, "ArgumentOutOfRangeException when array is new byte[1], start is 2 and length is 0");
 
             // Exception on index access
             byte[] array = new byte[16] { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F };
             Assert.ThrowsException(typeof(ArgumentOutOfRangeException), () =>
             {
-                SpanByte span = new SpanByte(array);
+                Span span = new Span(array);
                 var data = span[span.Length];
             });
             Assert.ThrowsException(typeof(IndexOutOfRangeException), () =>
             {
-                SpanByte span = new SpanByte(array);
+                Span span = new Span(array);
                 var data = span[-1];
             });
 
             // Copy to with too small destination
             Assert.ThrowsException(typeof(ArgumentException), () =>
             {
-                SpanByte span = new SpanByte(array);
-                SpanByte destination = new byte[span.Length - 1];
+                Span span = new Span(array);
+                Span destination = new byte[span.Length - 1];
                 span.CopyTo(destination);
             });
 
             // Slicing arguments
             Assert.ThrowsException(typeof(ArgumentOutOfRangeException), () =>
             {
-                SpanByte span = new SpanByte(array);
+                Span span = new Span(array);
                 var sliced = span.Slice(span.Length + 1);
             });
             Assert.ThrowsException(typeof(ArgumentOutOfRangeException), () =>
             {
-                SpanByte span = new SpanByte(array);
+                Span span = new Span(array);
                 var sliced = span.Slice(1, span.Length);
             });
 
             Assert.ThrowsException(typeof(ArgumentOutOfRangeException), () =>
             {
-                SpanByte span = new SpanByte(array);
+                Span span = new Span(array);
                 var sliced = span.Slice(-1, span.Length);
             });
 
             Assert.ThrowsException(typeof(ArgumentOutOfRangeException), () =>
             {
-                SpanByte span = new SpanByte(array);
+                Span span = new Span(array);
                 var sliced = span.Slice(1, -1);
             });
 
@@ -84,7 +84,7 @@ public void ToArrayTest()
         {
             byte[] array = new byte[16] { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F };
 
-            SpanByte span = new(array);
+            Span span = new(array);
 
             byte[] toArray = span.ToArray();
 
@@ -95,28 +95,28 @@ public void ToArrayTest()
         public void ConstructorsOfAllKindsTests()
         {
             // Empty span
-            SpanByte span = new SpanByte();
+            Span span = new Span();
             Assert.AreEqual(span.Length, 0, "Empty SpanByte should have length of 0");
             Assert.IsTrue(span.IsEmpty, "Empty SpanByte should be IsEmpty");
 
             // Empty span
-            span = new SpanByte(null, 0, 0);
+            span = new Span(null, 0, 0);
             Assert.AreEqual(span.Length, 0, "Empty SpanByte should have length of 0");
             Assert.IsTrue(span.IsEmpty, "Empty SpanByte should be IsEmpty");
 
             // Empty span
-            span = SpanByte.Empty;
+            span = Span.Empty;
             Assert.AreEqual(span.Length, 0, "Empty SpanByte should have length of 0");
             Assert.IsTrue(span.IsEmpty, "Empty SpanByte should be IsEmpty");
 
             // Span from normal array
             byte[] array = new byte[16] { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F };
-            span = new SpanByte(array);
+            span = new Span(array);
             Assert.AreEqual(span.Length, array.Length, $"SpanByte should have length of the array it takes: {array.Length}");
             Assert.IsFalse(span.IsEmpty, "SpanByte should NOT be IsEmpty");
 
             // Span from normal array with different start and length
-            span = new SpanByte(array, 2, 8);
+            span = new Span(array, 2, 8);
             Assert.AreEqual(span.Length, 8, $"SpanByte should have length of 8");
             Assert.IsFalse(span.IsEmpty, "SpanByte should NOT be IsEmpty");
         }
@@ -126,7 +126,7 @@ public void SliceTests()
         {
             // Span from normal array
             byte[] array = new byte[16] { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F };
-            SpanByte span = new SpanByte(array);
+            Span span = new Span(array);
             // Slice 2 elements and check
             var sliced = span.Slice(0, 2);
             Assert.AreEqual(sliced.Length, 2, "Sliced span lenght must be 2");
@@ -167,9 +167,9 @@ public void SliceTests()
         public void CopyToTests()
         {
             byte[] array = new byte[16] { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F };
-            SpanByte span = new SpanByte(array);
+            Span span = new Span(array);
             // First a copy to with the full span
-            SpanByte toCopy = new byte[span.Length];
+            Span toCopy = new byte[span.Length];
             span.CopyTo(toCopy);
             for (int i = 0; i < span.Length; i++)
             {
@@ -192,14 +192,14 @@ public void GetElementsTests()
         {
             // Span from normal array
             byte[] array = new byte[16] { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F };
-            SpanByte span = new SpanByte(array);
+            Span span = new Span(array);
             for (int i = 0; i < span.Length; i++)
             {
                 Assert.AreEqual(span[i], array[i], "SpanByte value should be the same as from the original array");
             }
 
             // Partial span
-            span = new SpanByte(array, 2, 8);
+            span = new Span(array, 2, 8);
             for (int i = 0; i < span.Length; i++)
             {
                 Assert.AreEqual(span[i], array[i + 2], "SpanByte value should be the same as from the original array");
@@ -210,7 +210,7 @@ public void GetElementsTests()
         public void SetElementsTests()
         {
             // Create a span, and set the data
-            SpanByte span = new byte[12];
+            Span span = new byte[12];
             // All should be 0
             for (int i = 0; i < span.Length; i++)
             {

nanoFramework.CoreLibrary/CoreLibrary.nfproj

@@ -66,6 +66,9 @@
     <Compile Include="System\AppDomainUnloadedException.cs" />
     <Compile Include="System\ApplicationException.cs" />
     <Compile Include="System\ArgumentException.cs" />
+    <Compile Include="System\ArrayTypeMismatchException.cs" />
+    <Compile Include="System\Diagnostics\StackTraceHiddenAttribute.cs" />
+    <Compile Include="System\Runtime\InteropServices\InAttribute .cs" />
     <Compile Include="System\Diagnostics\NativeProfiledAttribute.cs" />
     <Compile Include="System\PlatformNotSupportedException.cs" />
     <Compile Include="System\ArgumentNullException.cs" />
@@ -188,7 +191,9 @@
     <Compile Include="System\SByte.cs" />
     <Compile Include="System\SerializableAttribute.cs" />
     <Compile Include="System\Single.cs" />
-    <Compile Include="System\SpanByte.cs" />
+    <Compile Include="System\ReadOnlySpan.cs" />
+    <Compile Include="System\SpanDebugView.cs" />
+    <Compile Include="System\Span.cs" />
     <Compile Include="System\String.cs" />
     <Compile Include="System\SystemException.cs" />
     <Compile Include="System\TargetFrameworkAttribute.cs" />
@@ -251,4 +256,4 @@
   <Import Project="..\packages\Microsoft.SourceLink.Common.1.1.1\build\Microsoft.SourceLink.Common.targets" Condition="Exists('..\packages\Microsoft.SourceLink.Common.1.1.1\build\Microsoft.SourceLink.Common.targets')" />
   <Import Project="..\packages\Microsoft.SourceLink.GitHub.1.1.1\build\Microsoft.SourceLink.GitHub.targets" Condition="Exists('..\packages\Microsoft.SourceLink.GitHub.1.1.1\build\Microsoft.SourceLink.GitHub.targets')" />
   <Import Project="..\packages\Nerdbank.GitVersioning.3.7.115\build\Nerdbank.GitVersioning.targets" Condition="Exists('..\packages\Nerdbank.GitVersioning.3.7.115\build\Nerdbank.GitVersioning.targets')" />
-</Project>
+</Project>

nanoFramework.CoreLibrary/System/Array.cs

@@ -1,4 +1,4 @@
-// Licensed to the .NET Foundation under one or more agreements.
+// Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System.Collections;
@@ -343,9 +343,28 @@ public static int IndexOf(Array array, Object value, int startIndex, int count)
             return -1;
         }
 
+#if NANOCLR_REFLECTION
+        /// <summary>
+        /// Creates and returns an empty array of the specified type.
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <returns></returns>
+        public static T[] Empty<T>()
+        {
+            return EmptyArray<T>.Value;
+        }
+#endif
+
         [MethodImpl(MethodImplOptions.InternalCall)]
         private static extern bool TrySzIndexOf(Array sourceArray, int sourceIndex, int count, Object value, out int retVal);
 
+        private static class EmptyArray<T>
+        {
+#pragma warning disable CA1825, IDE0300 // this is the implementation of Array.Empty<T>()
+            internal static readonly T[] Value = new T[0];
+#pragma warning restore CA1825, IDE0300
+        }
+
         // This is the underlying Enumerator for all of our array-based data structures (Array, ArrayList, Stack, and Queue)
         // It supports enumerating over an array, a part of an array, and also will wrap around when the endIndex
         // specified is larger than the size of the array (to support Queue's internal circular array)

nanoFramework.CoreLibrary/System/ArrayTypeMismatchException.cs

@@ -0,0 +1,38 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace System
+{
+    /// <summary>
+    /// The exception that is thrown when an attempt is made to store an element of the wrong type within an array.
+    /// </summary>
+    [Serializable]
+    public class ArrayTypeMismatchException : SystemException
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ArrayTypeMismatchException"/> class.
+        /// </summary>
+        public ArrayTypeMismatchException()
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ArrayTypeMismatchException"/> class with a specified error message.
+        /// </summary>
+        /// <param name="message"></param>
+        public ArrayTypeMismatchException(string? message)
+            : base(message)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ArrayTypeMismatchException"/> class with a specified error message and a reference to the inner exception that is the cause of this exception.
+        /// </summary>
+        /// <param name="message"></param>
+        /// <param name="innerException"></param>
+        public ArrayTypeMismatchException(string? message, Exception? innerException)
+            : base(message, innerException)
+        {
+        }
+    }
+}

nanoFramework.CoreLibrary/System/Diagnostics/StackTraceHiddenAttribute.cs

@@ -0,0 +1,18 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace System.Diagnostics
+{
+    /// <summary>
+    /// Types and Methods attributed with StackTraceHidden will be omitted from the stack trace text shown in StackTrace.ToString()
+    /// and Exception.StackTrace
+    /// </summary>
+    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method | AttributeTargets.Constructor | AttributeTargets.Struct, Inherited = false)]
+    public sealed class StackTraceHiddenAttribute : Attribute
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="StackTraceHiddenAttribute"/> class.
+        /// </summary>
+        public StackTraceHiddenAttribute() { }
+    }
+}