.NET 5 target for Toolkit and HighPerformance packages (#3356)

## Adds the .NET 5 target to `Microsoft.Toolkit.HighPerformance`

## PR Type
What kind of change does this PR introduce?
<!-- Please uncomment one or more that apply to this PR. -->

<!-- - Bugfix -->
 - Feature
<!-- - Code style update (formatting) -->
<!-- - Refactoring (no functional changes, no api changes) -->
<!-- - Build or CI related changes -->
<!-- - Documentation content changes -->
<!-- - Sample app changes -->
<!-- - Other... Please describe: -->


## What is the current behavior?
<!-- Please describe the current behavior that you are modifying, or link to a relevant issue. -->
The `Microsoft.Toolkit.HighPerformance` package maxes out at .NET Core 3.1.
The `Microsoft.Toolkit` package maxes out at .NET Standard 2.1.

Additionally, `Microsoft.Toolkit` doesn't have proper nullability annotations, and it reports installing additional dependencies if installed in a .NET 5 apps. The extra dependency is `System.Runtime.CompilerServices.Unsafe` which is actually built-in on .NET 5, but consumers not aware of this would still see the installation prompt from NuGet as reporting an extra indirect dependency.

## What is the new behavior?
<!-- Describe how was this issue resolved or changed? -->
✅ Added .NET 5 target to `Microsoft.Toolkit.HighPerformance`
✅ Added .NET 5 target to `Microsoft.Toolkit`
✅ Enabled global nullability annotations to `Microsoft.Toolkit` and improved the codebase.
✅ Enabled C# 9 in both projects, with some extra code tweaks.

## PR Checklist

Please check if your PR fulfills the following requirements:

- [X] Tested code with current [supported SDKs](../readme.md#supported)
- [ ] Pull Request has been submitted to the documentation repository [instructions](..\contributing.md#docs). Link: <!-- docs PR link -->
- [ ] Sample in sample app has been added / updated (for bug fixes / features)
    - [ ] Icon has been created (if new sample) following the [Thumbnail Style Guide and templates](https://github.com/windows-toolkit/WindowsCommunityToolkit-design-assets)
- [ ] Tests for the changes have been added (for bug fixes / features) (if applicable)
- [X] Header has been added to all new source files (run *build/UpdateHeaders.bat*)
- [X] Contains **NO** breaking changes

<!-- If this PR contains a breaking change, please describe the impact and migration path for existing applications below. 
     Please note that breaking changes are likely to be rejected. -->

Author: msftbot[bot]

Microsoft.Toolkit.HighPerformance/Attributes/SkipLocalsInitAttribute.cs

@@ -0,0 +1,28 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+#if !NET5_0
+
+namespace System.Runtime.CompilerServices
+{
+    /// <summary>
+    /// Used to indicate to the compiler that the <c>.locals init</c> flag should not be set in method headers.
+    /// </summary>
+    /// <remarks>Internal copy of the .NET 5 attribute.</remarks>
+    [AttributeUsage(
+        AttributeTargets.Module |
+        AttributeTargets.Class |
+        AttributeTargets.Struct |
+        AttributeTargets.Interface |
+        AttributeTargets.Constructor |
+        AttributeTargets.Method |
+        AttributeTargets.Property |
+        AttributeTargets.Event,
+        Inherited = false)]
+    internal sealed class SkipLocalsInitAttribute : Attribute
+    {
+    }
+}
+
+#endif

Microsoft.Toolkit.HighPerformance/Buffers/MemoryOwner{T}.cs

@@ -7,7 +7,7 @@
 using System.Diagnostics;
 using System.Diagnostics.Contracts;
 using System.Runtime.CompilerServices;
-#if NETCORE_RUNTIME
+#if NETCORE_RUNTIME || NET5_0
 using System.Runtime.InteropServices;
 #endif
 using Microsoft.Toolkit.HighPerformance.Buffers.Views;
@@ -183,7 +183,7 @@ public Span<T> Span
                     ThrowObjectDisposedException();
                 }
 
-#if NETCORE_RUNTIME
+#if NETCORE_RUNTIME || NET5_0
                 ref T r0 = ref array!.DangerousGetReferenceAt(this.start);
 
                 // On .NET Core runtimes, we can manually create a span from the starting reference to

Microsoft.Toolkit.HighPerformance/Buffers/SpanOwner{T}.cs

@@ -7,7 +7,7 @@
 using System.Diagnostics;
 using System.Diagnostics.Contracts;
 using System.Runtime.CompilerServices;
-#if NETCORE_RUNTIME
+#if NETCORE_RUNTIME || NET5_0
 using System.Runtime.InteropServices;
 #endif
 using Microsoft.Toolkit.HighPerformance.Buffers.Views;
@@ -148,7 +148,7 @@ public Span<T> Span
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             get
             {
-#if NETCORE_RUNTIME
+#if NETCORE_RUNTIME || NET5_0
                 ref T r0 = ref array!.DangerousGetReference();
 
                 return MemoryMarshal.CreateSpan(ref r0, this.length);

Microsoft.Toolkit.HighPerformance/Buffers/StringPool.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.
 // See the LICENSE file in the project root for more information.
 

Microsoft.Toolkit.HighPerformance/Extensions/ArrayExtensions.1D.cs

@@ -5,7 +5,7 @@
 using System;
 using System.Diagnostics.Contracts;
 using System.Runtime.CompilerServices;
-#if NETCORE_RUNTIME
+#if NETCORE_RUNTIME || NET5_0
 using System.Runtime.InteropServices;
 #endif
 using Microsoft.Toolkit.HighPerformance.Enumerables;
@@ -30,7 +30,9 @@ public static partial class ArrayExtensions
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static ref T DangerousGetReference<T>(this T[] array)
         {
-#if NETCORE_RUNTIME
+#if NET5_0
+            return ref MemoryMarshal.GetArrayDataReference(array);
+#elif NETCORE_RUNTIME
             var arrayData = Unsafe.As<RawArrayData>(array)!;
             ref T r0 = ref Unsafe.As<byte, T>(ref arrayData.Data);
 
@@ -54,7 +56,12 @@ public static ref T DangerousGetReference<T>(this T[] array)
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static ref T DangerousGetReferenceAt<T>(this T[] array, int i)
         {
-#if NETCORE_RUNTIME
+#if NET5_0
+            ref T r0 = ref MemoryMarshal.GetArrayDataReference(array);
+            ref T ri = ref Unsafe.Add(ref r0, (nint)(uint)i);
+
+            return ref ri;
+#elif NETCORE_RUNTIME
             var arrayData = Unsafe.As<RawArrayData>(array)!;
             ref T r0 = ref Unsafe.As<byte, T>(ref arrayData.Data);
             ref T ri = ref Unsafe.Add(ref r0, (nint)(uint)i);
@@ -203,7 +210,7 @@ public static bool IsCovariant<T>(this T[] array)
         /// <summary>
         /// Throws an <see cref="OverflowException"/> when the "column" parameter is invalid.
         /// </summary>
-        public static void ThrowOverflowException()
+        private static void ThrowOverflowException()
         {
             throw new OverflowException();
         }

Microsoft.Toolkit.HighPerformance/Extensions/ArrayExtensions.2D.cs

@@ -451,15 +451,15 @@ private static void ThrowArrayTypeMismatchException()
         /// <summary>
         /// Throws an <see cref="ArgumentOutOfRangeException"/> when the "row" parameter is invalid.
         /// </summary>
-        public static void ThrowArgumentOutOfRangeExceptionForRow()
+        private static void ThrowArgumentOutOfRangeExceptionForRow()
         {
             throw new ArgumentOutOfRangeException("row");
         }
 
         /// <summary>
         /// Throws an <see cref="ArgumentOutOfRangeException"/> when the "column" parameter is invalid.
         /// </summary>
-        public static void ThrowArgumentOutOfRangeExceptionForColumn()
+        private static void ThrowArgumentOutOfRangeExceptionForColumn()
         {
             throw new ArgumentOutOfRangeException("column");
         }

Microsoft.Toolkit.HighPerformance/Extensions/ArrayExtensions.3D.cs

@@ -316,7 +316,7 @@ public static bool IsCovariant<T>(this T[,,] array)
         /// <summary>
         /// Throws an <see cref="ArgumentOutOfRangeException"/> when the "depth" parameter is invalid.
         /// </summary>
-        public static void ThrowArgumentOutOfRangeExceptionForDepth()
+        private static void ThrowArgumentOutOfRangeExceptionForDepth()
         {
             throw new ArgumentOutOfRangeException("depth");
         }

Microsoft.Toolkit.HighPerformance/Extensions/BoolExtensions.cs

@@ -21,9 +21,9 @@ public static class BoolExtensions
         /// <remarks>This method does not contain branching instructions.</remarks>
         [Pure]
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static byte ToByte(this bool flag)
+        public static unsafe byte ToByte(this bool flag)
         {
-            return Unsafe.As<bool, byte>(ref flag);
+            return *(byte*)&flag;
         }
 
         /// <summary>
@@ -35,9 +35,9 @@ public static byte ToByte(this bool flag)
         [Pure]
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         [Obsolete("Use ToByte instead.")]
-        public static int ToInt(this bool flag)
+        public static unsafe int ToInt(this bool flag)
         {
-            return Unsafe.As<bool, byte>(ref flag);
+            return *(byte*)&flag;
         }
 
         /// <summary>
@@ -56,9 +56,9 @@ public static int ToInt(this bool flag)
         /// </remarks>
         [Pure]
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int ToBitwiseMask32(this bool flag)
+        public static unsafe int ToBitwiseMask32(this bool flag)
         {
-            byte rangeFlag = Unsafe.As<bool, byte>(ref flag);
+            byte rangeFlag = *(byte*)&flag;
             int
                 negativeFlag = rangeFlag - 1,
                 mask = ~negativeFlag;
@@ -75,9 +75,9 @@ public static int ToBitwiseMask32(this bool flag)
         /// <remarks>This method does not contain branching instructions. See additional note in <see cref="ToBitwiseMask32"/>.</remarks>
         [Pure]
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static long ToBitwiseMask64(this bool flag)
+        public static unsafe long ToBitwiseMask64(this bool flag)
         {
-            byte rangeFlag = Unsafe.As<bool, byte>(ref flag);
+            byte rangeFlag = *(byte*)&flag;
             long
                 negativeFlag = (long)rangeFlag - 1,
                 mask = ~negativeFlag;

Microsoft.Toolkit.HighPerformance/Extensions/ListExtensions.cs

@@ -0,0 +1,42 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+#if NET5_0
+
+using System;
+using System.Collections.Generic;
+using System.Diagnostics.Contracts;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace Microsoft.Toolkit.HighPerformance.Extensions
+{
+    /// <summary>
+    /// Helpers for working with the <see cref="List{T}"/> type.
+    /// </summary>
+    public static class ListExtensions
+    {
+        /// <summary>
+        /// Creates a new <see cref="Span{T}"/> over an input <see cref="List{T}"/> instance.
+        /// </summary>
+        /// <typeparam name="T">The type of elements in the input <see cref="List{T}"/> instance.</typeparam>
+        /// <param name="list">The input <see cref="List{T}"/> instance.</param>
+        /// <returns>A <see cref="Span{T}"/> instance with the values of <paramref name="list"/>.</returns>
+        /// <remarks>
+        /// Note that the returned <see cref="Span{T}"/> is only guaranteed to be valid as long as the items within
+        /// <paramref name="list"/> are not modified. Doing so might cause the <see cref="List{T}"/> to swap its
+        /// internal buffer, causing the returned <see cref="Span{T}"/> to become out of date. That means that in this
+        /// scenario, the <see cref="Span{T}"/> would end up wrapping an array no longer in use. Always make sure to use
+        /// the returned <see cref="Span{T}"/> while the target <see cref="List{T}"/> is not modified.
+        /// </remarks>
+        [Pure]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static Span<T> AsSpan<T>(this List<T>? list)
+        {
+            return CollectionsMarshal.AsSpan(list);
+        }
+    }
+}
+
+#endif

Microsoft.Toolkit.HighPerformance/Extensions/ReadOnlySpanExtensions.cs

@@ -138,7 +138,7 @@ public static ref T DangerousGetReferenceAt<T>(this ReadOnlySpan<T> span, nint i
         /// </returns>
         [Pure]
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static ref readonly T DangerousGetLookupReferenceAt<T>(this ReadOnlySpan<T> span, int i)
+        public static unsafe ref readonly T DangerousGetLookupReferenceAt<T>(this ReadOnlySpan<T> span, int i)
         {
             // Check whether the input is in range by first casting both
             // operands to uint and then comparing them, as this allows
@@ -156,7 +156,7 @@ public static ref readonly T DangerousGetLookupReferenceAt<T>(this ReadOnlySpan<
             // bounds unless the input span was just empty, which for a
             // lookup table can just be assumed to always be false.
             bool isInRange = (uint)i < (uint)span.Length;
-            byte rangeFlag = Unsafe.As<bool, byte>(ref isInRange);
+            byte rangeFlag = *(byte*)&isInRange;
             uint
                 negativeFlag = unchecked(rangeFlag - 1u),
                 mask = ~negativeFlag,