[corlib] Default to fast Span<T> (#9204)

Part of #7249

mcs/class/System.Runtime.Serialization/Test/System.Runtime.Serialization.Json/DataContractJsonSerializerTest.cs

@@ -1550,14 +1550,17 @@ public void TestBitArraySerialization ()
 		public void TestHashtableSerialization ()
 		{
 			var collection = new HashtableContainer ();
-			var expectedOutput = "{\"Items\":[{\"Key\":\"key1\",\"Value\":\"banana\"},{\"Key\":\"key2\",\"Value\":\"apple\"}]}";
-
+			var expectedOutput_A = "{\"Items\":[{\"Key\":\"key1\",\"Value\":\"banana\"},{\"Key\":\"key2\",\"Value\":\"apple\"}]}";
+			var expectedOutput_B = "{\"Items\":[{\"Key\":\"key2\",\"Value\":\"apple\"},{\"Key\":\"key1\",\"Value\":\"banana\"}]}";
+
 			var serializer = new DataContractJsonSerializer (collection.GetType ());
 			var stream = new MemoryStream ();
 			serializer.WriteObject (stream, collection);
 
 			stream.Position = 0;
-			Assert.AreEqual (expectedOutput, new StreamReader (stream).ReadToEnd (), "#1");
+			var read = new StreamReader (stream).ReadToEnd ();
+
+			Assert.IsTrue (expectedOutput_A == read || expectedOutput_B == read, "#1");
 		}
 
 		[Test]

mcs/class/System.XML/Test/System.Xml.Serialization/ComplexDataStructure.cs

@@ -15,6 +15,7 @@
 using System.Collections;
 using System.ComponentModel; 
 using NUnit.Framework;
+using System.Linq;
 
 namespace MonoTests.System.XmlSerialization
 {
@@ -721,7 +722,7 @@ public void ReadXml (XmlReader reader)
 		public void WriteXml (XmlWriter writer)
 		{
 			writer.WriteStartElement ("data");
-			foreach (DictionaryEntry entry in data) 
+			foreach (DictionaryEntry entry in data.Cast<DictionaryEntry> ().OrderBy (l => l.Key)) 
 			{
 				writer.WriteElementString ((string)entry.Key, (string)entry.Value);
 			}

mcs/class/System.XML/Test/XmlFiles/literal-data.xml

@@ -248,9 +248,9 @@
     <anyType xsi:type="xsd:string">strings</anyType>
   </ttList>aa<xmltext>33</xmltext>bb<xmltext>776</xmltext><special>
     <data>
-      <two>2</two>
       <one>1</one>
       <three>3</three>
+      <two>2</two>
     </data>
   </special><dummyStringArray xmlns="mm">
     <ArrayOfString xsi:nil="true" />

mcs/class/corlib/Makefile

@@ -101,7 +101,7 @@ ifdef MONO_FEATURE_APPLE_X509
 LIB_MCS_FLAGS += -d:MONO_FEATURE_APPLE_X509
 endif
 
-COREFX_FLAGS := -d:FEATURE_PORTABLE_SPAN
+COREFX_FLAGS := -d:BIT64
 
 WARNING_ABOUT_DISABLED_WARNING=1635
 LOCAL_MCS_FLAGS = -unsafe -nostdlib -nowarn:612,618,3001,3002,3003,$(WARNING_ABOUT_DISABLED_WARNING) -d:INSIDE_CORLIB,MONO_CULTURE_DATA -d:LIBC $(REFERENCE_SOURCES_FLAGS) $(COREFX_FLAGS)

mcs/class/corlib/ReferenceSources/Buffer.cs

@@ -1,3 +1,12 @@
+#if BIT64
+using nuint = System.UInt64;
+#else
+using nuint = System.UInt32;
+#endif
+
+using System.Runtime.CompilerServices;
+using System.Runtime;
+
 namespace System
 {
 	partial class Buffer
@@ -213,7 +222,28 @@ public static unsafe void MemoryCopy (void* source, void* destination, ulong des
 
 		internal static unsafe void Memmove (byte *dest, byte *src, uint len)
 		{
+            if (((nuint)dest - (nuint)src < len) || ((nuint)src - (nuint)dest < len))
+				goto PInvoke;
 			Memcpy (dest, src, (int) len);
+			return;
+
+            PInvoke:
+            RuntimeImports.Memmove(dest, src, len);
+		}
+
+		internal static void Memmove<T>(ref T destination, ref T source, nuint elementCount)
+		{
+            if (!RuntimeHelpers.IsReferenceOrContainsReferences<T>()) {
+                unsafe {
+                    fixed (byte* pDestination = &Unsafe.As<T, byte>(ref destination), pSource = &Unsafe.As<T, byte>(ref source))
+                        Memmove(pDestination, pSource, (uint)elementCount * (uint)Unsafe.SizeOf<T>());
+                }
+			} else {
+                unsafe {
+                    fixed (byte* pDestination = &Unsafe.As<T, byte>(ref destination), pSource = &Unsafe.As<T, byte>(ref source))
+                        RuntimeImports.Memmove_wbarrier(pDestination, pSource, (uint)elementCount, typeof(T).TypeHandle.Value);
+				}
+			}
 		}
 	}
 }

mcs/class/corlib/ReferenceSources/String.cs

@@ -34,11 +34,19 @@
 //
 //
 
+#if BIT64
+using nuint = System.UInt64;
+#else
+using nuint = System.UInt32;
+#endif
+
 using System.Runtime.CompilerServices;
 using System.Text;
 using System.Globalization;
 using System.Collections;
 using System.Collections.Generic;
+using System.Runtime.InteropServices;
+using System.Diagnostics.Private;
 
 namespace System
 {
@@ -51,15 +59,6 @@ partial class String
 
 		public static readonly String Empty;
 
-		public unsafe static implicit operator ReadOnlySpan<char> (String value)
-		{
-			if (value == null)
-				return default;
-
-			fixed (void* start = &value._firstChar)
-				return new ReadOnlySpan<char> (start, value.Length);
-		}
-
 		internal unsafe int IndexOfUnchecked (string value, int startIndex, int count)
 		{
 			int valueLen = value.Length;
@@ -202,7 +201,12 @@ internal bool StartsWithOrdinalUnchecked (String value)
 			if (this.Length < value.Length || _firstChar != value._firstChar)
 				return false;
 
-			return value.Length == 1 ? true : StartsWithOrdinalHelper (this, value);
+			return value.Length == 1 ?
+				true :
+				SpanHelpers.SequenceEqual (
+					ref Unsafe.As<char, byte> (ref this.GetRawStringData ()),
+					ref Unsafe.As<char, byte> (ref value.GetRawStringData ()),
+					((nuint)value.Length) * 2);
 		}
 
 		[MethodImplAttribute (MethodImplOptions.InternalCall)]

mcs/class/corlib/ReferenceSources/TextInfo.cs

@@ -1,4 +1,5 @@
 using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
 
 namespace System.Globalization
 {
@@ -198,7 +199,7 @@ char ToLowerInternal (char c)
 			return c;
 		}
 
-		static unsafe int InternalCompareStringOrdinalIgnoreCase (String strA, int indexA, String strB, int indexB, int lenA, int lenB)
+		internal static unsafe int InternalCompareStringOrdinalIgnoreCase (String strA, int indexA, String strB, int indexB, int lenA, int lenB)
 		{
 			if (strA == null) {
 				return strB == null ? 0 : -1;
@@ -229,6 +230,47 @@ static unsafe int InternalCompareStringOrdinalIgnoreCase (String strA, int index
 				return lengthA - lengthB;
 			}
 		}
+
+		internal void ToLowerAsciiInvariant (ReadOnlySpan<char> source, Span<char> destination)
+		{
+			for (int i = 0; i < source.Length; i++)
+			{
+				destination [i] = ToLowerAsciiInvariant (source [i]);
+			}
+		}
+
+		internal void ToUpperAsciiInvariant (ReadOnlySpan<char> source, Span<char> destination)
+		{
+			for (int i = 0; i < source.Length; i++)
+			{
+				destination [i] = ToUpperAsciiInvariant (source[i]);
+			}
+		}
+
+		internal unsafe void ChangeCase (ReadOnlySpan<char> source, Span<char> destination, bool toUpper)
+		{
+			if (source.IsEmpty)
+				return;
+
+			var ti = CultureInfo.CurrentCulture.TextInfo;
+
+			fixed (char* pSource = &MemoryMarshal.GetReference (source))
+			fixed (char* pResult = &MemoryMarshal.GetReference (destination)) {
+				int length = 0;
+				char* a = pSource, b = pResult;
+				if (toUpper) {
+					while (length < source.Length) {
+						*b++ = ti.ToUpper (*a++);
+						length++;
+					}
+				} else {
+					while (length < source.Length) {
+						*b++ = ti.ToLower (*a++);
+						length++;
+					}
+				}
+			}
+		}
 	}
 
 	static class TextInfoToUpperData

mcs/class/corlib/System/Array.cs

@@ -65,6 +65,21 @@ internal bool InternalArray__ICollection_get_IsReadOnly ()
 			return true;
 		}
 
+		// adapted to the Mono array layout
+		[StructLayout(LayoutKind.Sequential)]
+		private class RawData
+		{
+			public IntPtr Bounds;
+			public IntPtr Count;
+			public byte Data;
+		}
+
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		internal ref byte GetRawSzArrayData()
+		{
+			return ref Unsafe.As<RawData>(this).Data;
+		}
+
 		internal IEnumerator<T> InternalArray__IEnumerable_GetEnumerator<T> ()
 		{
 			if (Length == 0)

mcs/class/corlib/corefx/CompareInfo.cs

@@ -90,22 +90,44 @@ unsafe int IndexOfCore (string source, string target, int startIndex, int count,
 
 		unsafe int IndexOfCore (ReadOnlySpan<char> source, ReadOnlySpan<char> target, CompareOptions options, int* matchLengthPtr)
 		{
-			throw new NotImplementedException ();
+			// TODO: optimize
+
+			var s = new string (source);
+			var t = new string (target);
+
+			return IndexOfCore (s, t, 0, s.Length, options, matchLengthPtr);
 		}
 
 		int IndexOfOrdinalCore (ReadOnlySpan<char> source, ReadOnlySpan<char> value, bool ignoreCase)
 		{
-			throw new NotImplementedException ();
+			// TODO: optimize
+
+			var s = new string (source);
+			var v = new string (value);
+
+			if (!ignoreCase)
+				return s.IndexOfUnchecked (v, 0, s.Length);
+
+			return s.IndexOfUncheckedIgnoreCase (v, 0, s.Length);
 		}
 
 		int CompareString (ReadOnlySpan<char> string1, string string2, CompareOptions options)
 		{
-			throw new NotImplementedException ();
+			// TODO: optimize
+
+			var s1 = new string (string1);
+
+			return internal_compare_switch (s1, 0, s1.Length, string2, 0, string2.Length, options);
 		}
 
 		int CompareString (ReadOnlySpan<char> string1, ReadOnlySpan<char> string2, CompareOptions options)
 		{
-			throw new NotImplementedException ();
+			// TODO: optimize
+
+			var s1 = new string (string1);
+			var s2 = new string (string2);
+
+			return internal_compare_switch (s1, 0, s1.Length, new string (s2), 0, s2.Length, options);
 		}
 
 		unsafe static bool IsSortable (char *text, int length)
@@ -137,7 +159,8 @@ bool StartsWith (string source, string prefix, CompareOptions options)
 
 		bool StartsWith (ReadOnlySpan<char> source, ReadOnlySpan<char> prefix, CompareOptions options)
 		{
-			throw new NotImplementedException ();
+			// TODO: optimize
+			return StartsWith (new string (source), new string (prefix), options);
 		}
 
 		bool EndsWith (string source, string suffix, CompareOptions options)
@@ -153,7 +176,8 @@ bool EndsWith (string source, string suffix, CompareOptions options)
 
 		bool EndsWith (ReadOnlySpan<char> source, ReadOnlySpan<char> suffix, CompareOptions options)
 		{
-			throw new NotImplementedException ();
+			// TODO: optimize
+			return EndsWith (new string (source), new string (suffix), options);
 		}
 
 		internal int GetHashCodeOfStringCore (string source, CompareOptions options)