Invalidate ByRefLikeArguments at end method interception

... and this appears to already catch possible usage mistakes in some
unit tests. Those need to be fixed next.

Author: stakx

src/Castle.Core/DynamicProxy/AbstractInvocation.cs

@@ -129,6 +129,26 @@ public void Proceed()
 			finally
 			{
 				currentInterceptorIndex--;
+
+#if FEATURE_BYREFLIKE
+				if (currentInterceptorIndex < 0)
+				{
+					// TODO: This will require further optimization;
+					// we should not iterate through the arguments array on a hot code path!
+					for (int i = 0; i < arguments.Length; ++i)
+					{
+						if (arguments[i] is ByRefLikeArgument byRefLikeArg)
+						{
+							// Invalidate the `ByRefLikeArgument` in case someone copied it away
+							// (i. e. let it escape the lifetime of the invocation and its arguments on the stack):
+							byRefLikeArg.Dispose();
+
+							// Reset the argument so the `ByRefLikeArgument` becomes eligible for GC sooner:
+							arguments[i] = null;
+						}
+					}
+				}
+#endif
 			}
 		}
 

src/Castle.Core/DynamicProxy/ByRefLikeArgument.cs

@@ -28,7 +28,7 @@ namespace Castle.DynamicProxy
 	///   Wraps a byref-like (<c>ref struct</c>) method argument
 	///   such that it can be placed in the <see cref="IInvocation.Arguments"/> array during interception.
 	/// </summary>
-	public unsafe class ByRefLikeArgument
+	public unsafe class ByRefLikeArgument : IDisposable
 	{
 		private static readonly ConcurrentDictionary<Type, ConstructorInfo> constructorMap = new();
 
@@ -95,12 +95,31 @@ public ByRefLikeArgument(void* ptr)
 		///     will cause undefined behavior, or an <see cref="AccessViolationException"/> at best.
 		///   </para>
 		/// </remarks>
+		/// <exception cref="ObjectDisposedException" />
 		[CLSCompliant(false)]
 		[EditorBrowsable(EditorBrowsableState.Advanced)]
 		public void* GetPointer()
 		{
+			EnsureNotDisposed();
+
 			return ptr;
 		}
+
+		public void Dispose()
+		{
+			ptr = null;
+		}
+
+		protected void EnsureNotDisposed()
+		{
+			if (ptr == null)
+			{
+				throw new ObjectDisposedException(
+					message: "Byref-like method arguments are only available during the method call. "
+					       + "This reference has been invalidated to prevent potentially unsafe access.",
+					objectName: null);
+			}
+		}
 	}
 
 #if FEATURE_ALLOWS_REF_STRUCT_ANTI_CONSTRAINT
@@ -124,8 +143,11 @@ public ByRefLikeArgument(void* ptr)
 		/// <summary>
 		///   Gets the byref-like (<c>ref struct</c>) argument.
 		/// </summary>
+		/// <exception cref="ObjectDisposedException" />
 		public ref TByRefLike Get()
 		{
+			EnsureNotDisposed();
+
 			return ref Unsafe.AsRef<TByRefLike>(ptr);
 		}
 	}
@@ -165,8 +187,11 @@ public ReadOnlySpanArgument(void* ptr)
 		/// <summary>
 		///   Gets the byref-like (<c>ref struct</c>) argument.
 		/// </summary>
+		/// <exception cref="ObjectDisposedException" />
 		public ref ReadOnlySpan<T> Get()
 		{
+			EnsureNotDisposed();
+
 #pragma warning disable CS8500
 			return ref *(ReadOnlySpan<T>*)ptr;
 #pragma warning restore CS8500
@@ -199,8 +224,11 @@ public SpanArgument(void* ptr)
 		/// <summary>
 		///   Gets the byref-like (<c>ref struct</c>) argument.
 		/// </summary>
+		/// <exception cref="ObjectDisposedException" />
 		public ref Span<T> Get()
 		{
+			EnsureNotDisposed();
+
 #pragma warning disable CS8500
 			return ref *(Span<T>*)ptr;
 #pragma warning restore CS8500