Enabled ByReference<T> usage in ref-like types

Microsoft.Toolkit.HighPerformance/Attributes/IgnoresAccessChecksToAttribute.cs

@@ -0,0 +1,31 @@
+// 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 NETCORE_RUNTIME
+
+namespace System.Runtime.CompilerServices
+{
+    /// <summary>
+    /// A special attribute recognized by CoreCLR that allows to ignore visibility checks for internal APIs.
+    /// </summary>
+    [AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
+    internal sealed class IgnoresAccessChecksToAttribute : Attribute
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="IgnoresAccessChecksToAttribute"/> class.
+        /// </summary>
+        /// <param name="assemblyName">The assembly name to use.</param>
+        public IgnoresAccessChecksToAttribute(string assemblyName)
+        {
+            AssemblyName = assemblyName;
+        }
+
+        /// <summary>
+        /// Gets the assembly name to use.
+        /// </summary>
+        public string AssemblyName { get; }
+    }
+}
+
+#endif

Microsoft.Toolkit.HighPerformance/Microsoft.Toolkit.HighPerformance.csproj

@@ -76,6 +76,16 @@
       </PropertyGroup>
     </When>
     <When Condition=" '$(TargetFramework)' == 'netcoreapp3.1' ">
+      <ItemGroup>
+
+        <!-- This is the fake System.Private.CoreLib assembly we need to be able to reference and use the
+             internal ByReference<T> type available on .NET Core 2.1+. The Private="false" property prevents
+             the resulting assembly from being copied to the output directory: this is what causes the runtime
+             to just use the real System.Private.CoreLib during execution (this project acts more like a proxy).
+             The PrivateAssets="all" property is used to hide this reference from NuGet, so that users adding a
+             reference to Microsoft.Toolkit.HighPerformance won't see the System.Private.CoreLib dependency. -->
+        <ProjectReference Include="..\System.Private.CoreLib\System.Private.CoreLib.csproj" Private="false" PrivateAssets="all" />
+      </ItemGroup>
       <PropertyGroup>
 
         <!-- NETCORE_RUNTIME: to avoid issues with APIs that assume a specific memory layout, we define a
@@ -91,6 +101,9 @@
       <ItemGroup>
         <PackageReference Include="System.Runtime.CompilerServices.Unsafe" Version="4.7.1" />
       </ItemGroup>
+      <ItemGroup>
+        <ProjectReference Include="..\System.Private.CoreLib\System.Private.CoreLib.csproj" Private="false" PrivateAssets="all" />
+      </ItemGroup>
       <PropertyGroup>
         <DefineConstants>SPAN_RUNTIME_SUPPORT;NETCORE_RUNTIME</DefineConstants>
       </PropertyGroup>

Microsoft.Toolkit.HighPerformance/NullableReadOnlyRef{T}.cs

@@ -6,7 +6,9 @@
 
 using System;
 using System.Runtime.CompilerServices;
+#if !NETCORE_RUNTIME
 using System.Runtime.InteropServices;
+#endif
 
 namespace Microsoft.Toolkit.HighPerformance
 {
@@ -16,6 +18,32 @@ namespace Microsoft.Toolkit.HighPerformance
     /// <typeparam name="T">The type of value to reference.</typeparam>
     public readonly ref struct NullableReadOnlyRef<T>
     {
+#if NETCORE_RUNTIME
+        /// <summary>
+        /// The <see cref="ByReference{T}"/> instance holding the current reference.
+        /// </summary>
+        private readonly ByReference<T> byReference;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="NullableReadOnlyRef{T}"/> struct.
+        /// </summary>
+        /// <param name="value">The readonly reference to the target <typeparamref name="T"/> value.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public NullableReadOnlyRef(in T value)
+        {
+            this.byReference = new ByReference<T>(ref Unsafe.AsRef(value));
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="NullableReadOnlyRef{T}"/> struct.
+        /// </summary>
+        /// <param name="byReference">The <see cref="ByReference{T}"/> instance holding the target reference.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private NullableReadOnlyRef(ByReference<T> byReference)
+        {
+            this.byReference = byReference;
+        }
+#else
         /// <summary>
         /// The 1-length <see cref="ReadOnlySpan{T}"/> instance used to track the target <typeparamref name="T"/> value.
         /// </summary>
@@ -42,6 +70,7 @@ private NullableReadOnlyRef(ReadOnlySpan<T> span)
         {
             this.span = span;
         }
+#endif
 
         /// <summary>
         /// Gets a <see cref="NullableReadOnlyRef{T}"/> instance representing a <see langword="null"/> reference.
@@ -60,10 +89,17 @@ public bool HasValue
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             get
             {
+#if NETCORE_RUNTIME
+                unsafe
+                {
+                    return !Unsafe.AreSame(ref this.byReference.Value, ref Unsafe.AsRef<T>(null));
+                }
+#else
                 // See comment in NullableRef<T> about this
                 byte length = unchecked((byte)this.span.Length);
 
                 return Unsafe.As<byte, bool>(ref length);
+#endif
             }
         }
 
@@ -81,7 +117,11 @@ public ref readonly T Value
                     ThrowInvalidOperationException();
                 }
 
+#if NETCORE_RUNTIME
+                return ref this.byReference.Value;
+#else
                 return ref MemoryMarshal.GetReference(this.span);
+#endif
             }
         }
 
@@ -92,7 +132,11 @@ public ref readonly T Value
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static implicit operator NullableReadOnlyRef<T>(Ref<T> reference)
         {
+#if NETCORE_RUNTIME
+            return new NullableReadOnlyRef<T>(reference.ByReference);
+#else
             return new NullableReadOnlyRef<T>(reference.Span);
+#endif
         }
 
         /// <summary>
@@ -102,7 +146,11 @@ public static implicit operator NullableReadOnlyRef<T>(Ref<T> reference)
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static implicit operator NullableReadOnlyRef<T>(ReadOnlyRef<T> reference)
         {
+#if NETCORE_RUNTIME
+            return new NullableReadOnlyRef<T>(reference.ByReference);
+#else
             return new NullableReadOnlyRef<T>(reference.Span);
+#endif
         }
 
         /// <summary>
@@ -112,7 +160,11 @@ public static implicit operator NullableReadOnlyRef<T>(ReadOnlyRef<T> reference)
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static implicit operator NullableReadOnlyRef<T>(NullableRef<T> reference)
         {
+#if NETCORE_RUNTIME
+            return new NullableReadOnlyRef<T>(reference.ByReference);
+#else
             return new NullableReadOnlyRef<T>(reference.Span);
+#endif
         }
 
         /// <summary>

Microsoft.Toolkit.HighPerformance/NullableRef{T}.cs

@@ -6,7 +6,9 @@
 
 using System;
 using System.Runtime.CompilerServices;
+#if !NETCORE_RUNTIME
 using System.Runtime.InteropServices;
+#endif
 
 namespace Microsoft.Toolkit.HighPerformance
 {
@@ -16,6 +18,32 @@ namespace Microsoft.Toolkit.HighPerformance
     /// <typeparam name="T">The type of value to reference.</typeparam>
     public readonly ref struct NullableRef<T>
     {
+#if NETCORE_RUNTIME
+        /// <summary>
+        /// The <see cref="ByReference{T}"/> instance holding the current reference.
+        /// </summary>
+        internal readonly ByReference<T> ByReference;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="NullableRef{T}"/> struct.
+        /// </summary>
+        /// <param name="value">The readonly reference to the target <typeparamref name="T"/> value.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public NullableRef(ref T value)
+        {
+            ByReference = new ByReference<T>(ref value);
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="NullableRef{T}"/> struct.
+        /// </summary>
+        /// <param name="byReference">The <see cref="ByReference{T}"/> instance holding the target reference.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private NullableRef(ByReference<T> byReference)
+        {
+            ByReference = byReference;
+        }
+#else
         /// <summary>
         /// The 1-length <see cref="Span{T}"/> instance used to track the target <typeparamref name="T"/> value.
         /// </summary>
@@ -40,6 +68,7 @@ private NullableRef(Span<T> span)
         {
             Span = span;
         }
+#endif
 
         /// <summary>
         /// Gets a <see cref="NullableRef{T}"/> instance representing a <see langword="null"/> reference.
@@ -58,6 +87,12 @@ public bool HasValue
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             get
             {
+#if NETCORE_RUNTIME
+                unsafe
+                {
+                    return !Unsafe.AreSame(ref ByReference.Value, ref Unsafe.AsRef<T>(null));
+                }
+#else
                 // 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
@@ -68,6 +103,7 @@ public bool HasValue
                 byte length = unchecked((byte)Span.Length);
 
                 return Unsafe.As<byte, bool>(ref length);
+#endif
             }
         }
 
@@ -85,7 +121,11 @@ public ref T Value
                     ThrowInvalidOperationException();
                 }
 
+#if NETCORE_RUNTIME
+                return ref ByReference.Value;
+#else
                 return ref MemoryMarshal.GetReference(Span);
+#endif
             }
         }
 
@@ -96,7 +136,11 @@ public ref T Value
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static implicit operator NullableRef<T>(Ref<T> reference)
         {
+#if NETCORE_RUNTIME
+            return new NullableRef<T>(reference.ByReference);
+#else
             return new NullableRef<T>(reference.Span);
+#endif
         }
 
         /// <summary>

Microsoft.Toolkit.HighPerformance/Properties/AssemblyInfo.cs

@@ -0,0 +1,20 @@
+// 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 NETCORE_RUNTIME
+
+using System.Runtime.CompilerServices;
+
+// This is needed so that the runtime will actually let us access the internal
+// ByReference<T> type exposed through the fake System.Private.CoreLib assembly
+// that is referenced by this project. The reason for this is that while the proxy
+// type we declared belongs to a project we have internals access to, the real
+// ByReference<T> from the actual CoreLib assembly does not, so the runtime would
+// normally fail to load the type if this attribute wasn't present.
+// Note that while this attribute is internally recognized by the runtime, we still
+// need the fake CoreLib assembly to be able to use the type when building from source,
+// as Roslyn itself does not actually recognize and/or respect it.
+[assembly: IgnoresAccessChecksTo("System.Private.CoreLib")]
+
+#endif