Bump HighPerformance package to .NET 7

Author: Sergio0694

CommunityToolkit.HighPerformance/CommunityToolkit.HighPerformance.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFrameworks>netstandard2.0;netstandard2.1;netcoreapp3.1;net6.0</TargetFrameworks>
+    <TargetFrameworks>netstandard2.0;netstandard2.1;netcoreapp3.1;net6.0;net7.0</TargetFrameworks>
   </PropertyGroup>
 
   <PropertyGroup>
@@ -45,7 +45,7 @@
       </ItemGroup>
     </When>
 
-    <When Condition="'$(TargetFramework)' == 'net6.0'">
+    <When Condition="'$(TargetFramework)' == 'net6.0' OR '$(TargetFramework)' == 'net7.0'">
 
       <!-- NETSTANDARD2_1_OR_GREATER: includes both .NET Standard 2.1, .NET Core 3.1 and .NET 6.
            Additionally, also enable trimming support on .NET 6. -->

CommunityToolkit.HighPerformance/Extensions/SpinLockExtensions.cs

@@ -2,11 +2,9 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
+using System;
 using System.ComponentModel;
 using System.Runtime.CompilerServices;
-#if NETSTANDARD2_1_OR_GREATER
-using System.Runtime.Versioning;
-#endif
 using System.Threading;
 
 namespace CommunityToolkit.HighPerformance;
@@ -33,6 +31,8 @@ public static class SpinLockExtensions
     /// <returns>A wrapper type that will release <paramref name="spinLock"/> when its <see cref="System.IDisposable.Dispose"/> method is called.</returns>
     /// <remarks>The returned <see cref="UnsafeLock"/> value shouldn't be used directly: use this extension in a <see langword="using"/> block or statement.</remarks>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [Obsolete("Use SpinLockExtensions.Enter(ref SpinLock) instead.")]
+    [EditorBrowsable(EditorBrowsableState.Never)]
     public static unsafe UnsafeLock Enter(SpinLock* spinLock)
     {
         return new(spinLock);
@@ -80,7 +80,7 @@ public void Dispose()
         }
     }
 
-#if NETSTANDARD2_1_OR_GREATER
+#if NET7_0_OR_GREATER
     /// <summary>
     /// Enters a specified <see cref="SpinLock"/> instance and returns a wrapper to use to release the lock.
     /// This extension should be used though a <see langword="using"/> block or statement:
@@ -97,9 +97,6 @@ public void Dispose()
     /// <param name="spinLock">The target <see cref="SpinLock"/> to use</param>
     /// <returns>A wrapper type that will release <paramref name="spinLock"/> when its <see cref="System.IDisposable.Dispose"/> method is called.</returns>
     /// <remarks>The returned <see cref="Lock"/> value shouldn't be used directly: use this extension in a <see langword="using"/> block or statement.</remarks>
-    [RequiresPreviewFeatures(
-        "The Lock type has no compiler support to ensure the lifetime of referenced values is respected, and as such using it incorrectly may lead to GC holes.",
-        Url = "https://github.com/dotnet/runtime/issues/46104")]
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static Lock Enter(ref this SpinLock spinLock)
     {
@@ -110,15 +107,12 @@ public static Lock Enter(ref this SpinLock spinLock)
     /// A <see langword="struct"/> that is used to enter and hold a <see cref="SpinLock"/> through a <see langword="using"/> block or statement.
     /// </summary>
     [EditorBrowsable(EditorBrowsableState.Never)]
-    [RequiresPreviewFeatures(
-        "The Lock type has no compiler support to ensure the lifetime of referenced values is respected, and as such using it incorrectly may lead to GC holes.",
-        Url = "https://github.com/dotnet/runtime/issues/46104")]
     public readonly ref struct Lock
     {
         /// <summary>
-        /// The <see cref="Ref{T}"/> instance pointing to the target <see cref="SpinLock"/> value to use.
+        /// The reference to the target <see cref="SpinLock"/> value to use.
         /// </summary>
-        private readonly Ref<SpinLock> spinLock;
+        private readonly ref SpinLock spinLock;
 
         /// <summary>
         /// A value indicating whether or not the lock is taken by this <see cref="Lock"/> instance.
@@ -132,7 +126,7 @@ public readonly ref struct Lock
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         internal Lock(ref SpinLock spinLock)
         {
-            this.spinLock = new Ref<SpinLock>(ref spinLock);
+            this.spinLock = ref spinLock;
             this.lockTaken = false;
 
             spinLock.Enter(ref this.lockTaken);
@@ -146,7 +140,7 @@ public void Dispose()
         {
             if (this.lockTaken)
             {
-                this.spinLock.Value.Exit();
+                this.spinLock.Exit();
             }
         }
     }

CommunityToolkit.HighPerformance/NullableReadOnlyRef{T}.cs

@@ -2,28 +2,23 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-#if NETSTANDARD2_1_OR_GREATER
+#if NET7_0_OR_GREATER
 
 using System;
 using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-using System.Runtime.Versioning;
 
 namespace CommunityToolkit.HighPerformance;
 
 /// <summary>
 /// A <see langword="struct"/> that can store an optional readonly reference to a value of a specified type.
 /// </summary>
 /// <typeparam name="T">The type of value to reference.</typeparam>
-[RequiresPreviewFeatures(
-    "The NullableReadOnlyRef<T> type has no compiler support to ensure the lifetime of referenced values is respected, and as such using it incorrectly may lead to GC holes.",
-    Url = "https://github.com/dotnet/runtime/issues/46104")]
 public readonly ref struct NullableReadOnlyRef<T>
 {
     /// <summary>
-    /// The 1-length <see cref="ReadOnlySpan{T}"/> instance used to track the target <typeparamref name="T"/> value.
+    /// The reference to the target <typeparamref name="T"/> value.
     /// </summary>
-    private readonly ReadOnlySpan<T> span;
+    private readonly ref readonly T value;
 
     /// <summary>
     /// Initializes a new instance of the <see cref="NullableReadOnlyRef{T}"/> struct.
@@ -32,19 +27,7 @@ public readonly ref struct NullableReadOnlyRef<T>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public NullableReadOnlyRef(in T value)
     {
-        ref T r0 = ref Unsafe.AsRef(value);
-
-        this.span = MemoryMarshal.CreateReadOnlySpan(ref r0, 1);
-    }
-
-    /// <summary>
-    /// Initializes a new instance of the <see cref="NullableReadOnlyRef{T}"/> struct.
-    /// </summary>
-    /// <param name="span">The <see cref="ReadOnlySpan{T}"/> instance to track the target <typeparamref name="T"/> reference.</param>
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private NullableReadOnlyRef(ReadOnlySpan<T> span)
-    {
-        this.span = span;
+        this.value = ref value;
     }
 
     /// <summary>
@@ -62,13 +45,7 @@ public static NullableReadOnlyRef<T> Null
     public unsafe bool HasValue
     {
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        get
-        {
-            // See comment in NullableRef<T> about this
-            byte length = unchecked((byte)this.span.Length);
-
-            return *(bool*)&length;
-        }
+        get => !Unsafe.IsNullRef(ref Unsafe.AsRef(in this.value));
     }
 
     /// <summary>
@@ -85,7 +62,7 @@ public ref readonly T Value
                 ThrowInvalidOperationException();
             }
 
-            return ref MemoryMarshal.GetReference(this.span);
+            return ref this.value;
         }
     }
 
@@ -96,7 +73,7 @@ public ref readonly T Value
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static implicit operator NullableReadOnlyRef<T>(Ref<T> reference)
     {
-        return new(reference.Span);
+        return new(in reference.Value);
     }
 
     /// <summary>
@@ -106,7 +83,7 @@ public static implicit operator NullableReadOnlyRef<T>(Ref<T> reference)
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static implicit operator NullableReadOnlyRef<T>(ReadOnlyRef<T> reference)
     {
-        return new(reference.Span);
+        return new(in reference.Value);
     }
 
     /// <summary>
@@ -116,7 +93,7 @@ public static implicit operator NullableReadOnlyRef<T>(ReadOnlyRef<T> reference)
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static implicit operator NullableReadOnlyRef<T>(NullableRef<T> reference)
     {
-        return new(reference.Span);
+        return new(in reference.Value);
     }
 
     /// <summary>

CommunityToolkit.HighPerformance/NullableRef{T}.cs

@@ -2,28 +2,23 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-#if NETSTANDARD2_1_OR_GREATER
+#if NET7_0_OR_GREATER
 
 using System;
 using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-using System.Runtime.Versioning;
 
 namespace CommunityToolkit.HighPerformance;
 
 /// <summary>
 /// A <see langword="struct"/> that can store an optional reference to a value of a specified type.
 /// </summary>
 /// <typeparam name="T">The type of value to reference.</typeparam>
-[RequiresPreviewFeatures(
-    "The NullableRef<T> type has no compiler support to ensure the lifetime of referenced values is respected, and as such using it incorrectly may lead to GC holes.",
-    Url = "https://github.com/dotnet/runtime/issues/46104")]
 public readonly ref struct NullableRef<T>
 {
     /// <summary>
-    /// The 1-length <see cref="Span{T}"/> instance used to track the target <typeparamref name="T"/> value.
+    /// The reference to the target <typeparamref name="T"/> value.
     /// </summary>
-    internal readonly Span<T> Span;
+    private readonly ref T value;
 
     /// <summary>
     /// Initializes a new instance of the <see cref="NullableRef{T}"/> struct.
@@ -32,17 +27,7 @@ public readonly ref struct NullableRef<T>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public NullableRef(ref T value)
     {
-        this.Span = MemoryMarshal.CreateSpan(ref value, 1);
-    }
-
-    /// <summary>
-    /// Initializes a new instance of the <see cref="NullableRef{T}"/> struct.
-    /// </summary>
-    /// <param name="span">The <see cref="Span{T}"/> instance to track the target <typeparamref name="T"/> reference.</param>
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private NullableRef(Span<T> span)
-    {
-        this.Span = span;
+        this.value = ref value;
     }
 
     /// <summary>
@@ -60,19 +45,7 @@ public static NullableRef<T> Null
     public unsafe bool HasValue
     {
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        get
-        {
-            // We know that the span will always have a length of either
-            // 1 or 0, so instead of using a cmp instruction and setting the
-            // zero flag to produce our boolean value, we can just cast
-            // the length to byte without overflow checks (doing a cast will
-            // also account for the byte endianness of the current system),
-            // and then reinterpret that value to a bool flag.
-            // This results in a single movzx instruction on x86-64.
-            byte length = unchecked((byte)this.Span.Length);
-
-            return *(bool*)&length;
-        }
+        get => !Unsafe.IsNullRef(ref this.value);
     }
 
     /// <summary>
@@ -89,7 +62,7 @@ public ref T Value
                 ThrowInvalidOperationException();
             }
 
-            return ref MemoryMarshal.GetReference(this.Span);
+            return ref this.value;
         }
     }
 
@@ -100,7 +73,7 @@ public ref T Value
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static implicit operator NullableRef<T>(Ref<T> reference)
     {
-        return new(reference.Span);
+        return new(ref reference.Value);
     }
 
     /// <summary>