Introduce type-safe [ReadOnly]SpanArgument<T> for .NET 8

This yields the following `ByRefLikeArgument` type hierarchy on .NET 8:

    ByRefLikeArgument
        ^
        |
        +-- SpanArgument<T>
        |
        |
        +-- ReadOnlySpanArgument<T>

While on .NET 9, there is an intermediate generic type (which wouldn't
be allowed on earlier runtimes):

    ByRefLikeArgument
        ^
        |
        +-- ByRefLikeArgument<TByRefLike>
                ^
                |
                +-- SpanArgument<T>
                |   (with TByRefLike = Span<T>)
                |
                |
                +-- ReadOnlySpanArgument<T>
                    (with TByRefLike = ReadOnlySpan<T>)

The intention behind those different hiearchies is to give .NET 8 users
a type-safe argument wrapper for spans, too (because those have become
commonly encountered types), while allowing .NET 9 code to ignore those
specialized span variants and testing only for the more generic inter-
mediate type.

Hopefully this won't bite us in the future.

Author: stakx

src/Castle.Core.Tests/DynamicProxy.Tests/ByRefLikeTestCase.cs

@@ -206,6 +206,10 @@ public void By_ref_like_arguments_are_wrapped_as_ByRefLikeArgument_in_invocation
 			var arg = "original".AsSpan();
 			proxy.Method(arg);
 			Assert.IsInstanceOf<ByRefLikeArgument>(interceptor.ObservedArg);
+			Assert.IsInstanceOf<ReadOnlySpanArgument<char>>(interceptor.ObservedArg);
+#if FEATURE_ALLOWS_REF_STRUCT_ANTI_CONSTRAINT
+			Assert.IsInstanceOf<ByRefLikeArgument<ReadOnlySpan<char>>>(interceptor.ObservedArg);
+#endif
 		}
 
 		[Test]
@@ -244,6 +248,10 @@ public void By_ref_like_in_arguments_are_wrapped_as_ByRefLikeArgument_in_invocat
 			var arg = "original".AsSpan();
 			proxy.Method(in arg);
 			Assert.IsInstanceOf<ByRefLikeArgument>(interceptor.ObservedArg);
+			Assert.IsInstanceOf<ReadOnlySpanArgument<char>>(interceptor.ObservedArg);
+#if FEATURE_ALLOWS_REF_STRUCT_ANTI_CONSTRAINT
+			Assert.IsInstanceOf<ByRefLikeArgument<ReadOnlySpan<char>>>(interceptor.ObservedArg);
+#endif
 		}
 
 		[Test]
@@ -282,6 +290,10 @@ public void By_ref_like_ref_arguments_are_wrapped_as_ByRefLikeArgument_in_invoca
 			var arg = "original".AsSpan();
 			proxy.Method(ref arg);
 			Assert.IsInstanceOf<ByRefLikeArgument>(interceptor.ObservedArg);
+			Assert.IsInstanceOf<ReadOnlySpanArgument<char>>(interceptor.ObservedArg);
+#if FEATURE_ALLOWS_REF_STRUCT_ANTI_CONSTRAINT
+			Assert.IsInstanceOf<ByRefLikeArgument<ReadOnlySpan<char>>>(interceptor.ObservedArg);
+#endif
 		}
 
 		[Test]
@@ -323,6 +335,10 @@ public void By_ref_like_out_arguments_are_wrapped_as_ByRefLikeArgument_in_invoca
 			var arg = "original".AsSpan();
 			proxy.Method(out arg);
 			Assert.IsInstanceOf<ByRefLikeArgument>(interceptor.ObservedArg);
+			Assert.IsInstanceOf<ReadOnlySpanArgument<char>>(interceptor.ObservedArg);
+#if FEATURE_ALLOWS_REF_STRUCT_ANTI_CONSTRAINT
+			Assert.IsInstanceOf<ByRefLikeArgument<ReadOnlySpan<char>>>(interceptor.ObservedArg);
+#endif
 		}
 
 		// Should theoretically be as above (read comment there), but isn't. To be revisited later!

src/Castle.Core/DynamicProxy/ByRefLikeArgument.cs

@@ -30,26 +30,38 @@ namespace Castle.DynamicProxy
 	/// </summary>
 	public unsafe class ByRefLikeArgument
 	{
-#if FEATURE_ALLOWS_REF_STRUCT_ANTI_CONSTRAINT
 		private static readonly ConcurrentDictionary<Type, ConstructorInfo> constructorMap = new();
 
 		internal static ConstructorInfo GetConstructorFor(Type byRefLikeType)
 		{
 			return constructorMap.GetOrAdd(byRefLikeType, static byRefLikeType =>
 			{
-				var type = typeof(ByRefLikeArgument<>).MakeGenericType(byRefLikeType);
-				return type.GetConstructor([ typeof(void*) ])!;
-			});
-		}
+				Type? type = null;
+
+				if  (byRefLikeType.IsConstructedGenericType)
+				{
+					var typeDef = byRefLikeType.GetGenericTypeDefinition();
+					if (typeDef == typeof(Span<>))
+					{
+						var typeArg = byRefLikeType.GetGenericArguments()[0];
+						type = typeof(SpanArgument<>).MakeGenericType(typeArg);
+					}
+					else if (typeDef == typeof(ReadOnlySpan<>))
+					{
+						var typeArg = byRefLikeType.GetGenericArguments()[0];
+						type = typeof(ReadOnlySpanArgument<>).MakeGenericType(typeArg);
+					}
+				}
+
+#if FEATURE_ALLOWS_REF_STRUCT_ANTI_CONSTRAINT
+				type ??= typeof(ByRefLikeArgument<>).MakeGenericType(byRefLikeType);
 #else
-		private static readonly ConstructorInfo constructor =
-			typeof(ByRefLikeArgument).GetConstructor([ typeof(void*) ])!;
+				type ??= typeof(ByRefLikeArgument);
+#endif
 
-		internal static ConstructorInfo GetConstructorFor(Type byRefLikeType)
-		{
-			return constructor;
+				return type.GetConstructor([ typeof(void*) ])!;
+			});
 		}
-#endif
 
 		protected void* ptr;
 
@@ -103,6 +115,81 @@ public ref TByRefLike Get()
 
 #endif
 
+	// The following two specializations for `Span<T>` and `ReadOnlySpan<T>` are provided
+	// because those two types have become so common in the Framework Class Library, and
+	// dealing with them through unmanaged pointers all the time would be cumbersome.
+	// We can provide a type-safe wrapper for them even on .NET 8. And we keep the types
+	// for .NET 9 (even though they're redundant) so downstream code can expect to always
+	// encounter a `[ReadOnly]SpanArgument<>` for `[ReadOnly]Span<>` regardless of
+	// whether they target .NET 8 or 9.
+
+	/// <summary>
+	///   Wraps a <see cref="ReadOnlySpan{T}"/> method argument
+	///   such that it can be placed in the <see cref="IInvocation.Arguments"/> array during interception.
+	/// </summary>
+	public unsafe class ReadOnlySpanArgument<T>
+#if FEATURE_ALLOWS_REF_STRUCT_ANTI_CONSTRAINT
+		: ByRefLikeArgument<ReadOnlySpan<T>>
+#else
+		: ByRefLikeArgument
+#endif
+	{
+		/// <summary>
+		///   Do not use this! Only generated proxies should construct instances this type.
+		/// </summary>
+		[CLSCompliant(false)]
+		[EditorBrowsable(EditorBrowsableState.Never)]
+		public ReadOnlySpanArgument(void* ptr)
+			: base(ptr)
+		{
+		}
+
+#if !FEATURE_ALLOWS_REF_STRUCT_ANTI_CONSTRAINT
+		/// <summary>
+		///   Gets the byref-like (<c>ref struct</c>) argument.
+		/// </summary>
+		public ref ReadOnlySpan<T> Get()
+		{
+#pragma warning disable CS8500
+			return ref *(ReadOnlySpan<T>*)ptr;
+#pragma warning restore CS8500
+		}
+#endif
+	}
+
+	/// <summary>
+	///   Wraps a <see cref="Span{T}"/> method argument
+	///   such that it can be placed in the <see cref="IInvocation.Arguments"/> array during interception.
+	/// </summary>
+	public unsafe class SpanArgument<T>
+#if FEATURE_ALLOWS_REF_STRUCT_ANTI_CONSTRAINT
+		: ByRefLikeArgument<Span<T>>
+#else
+		: ByRefLikeArgument
+#endif
+	{
+		/// <summary>
+		///   Do not use this! Only generated proxies should construct instances this type.
+		/// </summary>
+		[CLSCompliant(false)]
+		[EditorBrowsable(EditorBrowsableState.Never)]
+		public SpanArgument(void* ptr)
+			: base(ptr)
+		{
+		}
+
+#if !FEATURE_ALLOWS_REF_STRUCT_ANTI_CONSTRAINT
+		/// <summary>
+		///   Gets the byref-like (<c>ref struct</c>) argument.
+		/// </summary>
+		public ref Span<T> Get()
+		{
+#pragma warning disable CS8500
+			return ref *(Span<T>*)ptr;
+#pragma warning restore CS8500
+		}
+#endif
+	}
 }
 
 #endif