refactor(attributes): replace RequiresDynamicCode with RequiresUnrefe…

…rencedCode for AOT compatibility

TUnit.Assertions.SourceGenerator/Generators/AssertionExtensionGenerator.cs

@@ -92,13 +92,13 @@ public void Initialize(IncrementalGeneratorInitializationContext context)
             return null;
         }
 
-        // Check for RequiresDynamicCode attribute
-        var requiresDynamicCodeAttr = classSymbol.GetAttributes()
-            .FirstOrDefault(attr => attr.AttributeClass?.Name == "RequiresDynamicCodeAttribute");
-        string? requiresDynamicCodeMessage = null;
-        if (requiresDynamicCodeAttr != null && requiresDynamicCodeAttr.ConstructorArguments.Length > 0)
+        // Check for RequiresUnreferencedCode attribute
+        var RequiresUnreferencedCodeAttr = classSymbol.GetAttributes()
+            .FirstOrDefault(attr => attr.AttributeClass?.Name == "RequiresUnreferencedCodeAttribute");
+        string? RequiresUnreferencedCodeMessage = null;
+        if (RequiresUnreferencedCodeAttr != null && RequiresUnreferencedCodeAttr.ConstructorArguments.Length > 0)
         {
-            requiresDynamicCodeMessage = requiresDynamicCodeAttr.ConstructorArguments[0].Value?.ToString();
+            RequiresUnreferencedCodeMessage = RequiresUnreferencedCodeAttr.ConstructorArguments[0].Value?.ToString();
         }
 
         return new AssertionExtensionData(
@@ -108,7 +108,7 @@ public void Initialize(IncrementalGeneratorInitializationContext context)
             assertionBaseType,
             constructors,
             overloadPriority,
-            requiresDynamicCodeMessage
+            RequiresUnreferencedCodeMessage
         );
     }
 
@@ -153,7 +153,7 @@ private static void GenerateExtensionMethods(SourceProductionContext context, As
 
         sourceBuilder.AppendLine($"namespace TUnit.Assertions.Extensions;");
         sourceBuilder.AppendLine();
-    
+
         // Extension class
         var extensionClassName = $"{data.ClassSymbol.Name}Extensions";
         sourceBuilder.AppendLine($"/// <summary>");
@@ -309,11 +309,11 @@ private static void GenerateExtensionMethod(
         sourceBuilder.AppendLine($"    /// Extension method for {assertionType.Name}.");
         sourceBuilder.AppendLine("    /// </summary>");
 
-        // Add RequiresDynamicCode attribute if present
-        if (!string.IsNullOrEmpty(data.RequiresDynamicCodeMessage))
+        // Add RequiresUnreferencedCode attribute if present
+        if (!string.IsNullOrEmpty(data.RequiresUnreferencedCodeMessage))
         {
-            var escapedMessage = data.RequiresDynamicCodeMessage!.Replace("\"", "\\\"");
-            sourceBuilder.AppendLine($"    [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode(\"{escapedMessage}\")]");
+            var escapedMessage = data.RequiresUnreferencedCodeMessage!.Replace("\"", "\\\"");
+            sourceBuilder.AppendLine($"    [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode(\"{escapedMessage}\")]");
         }
 
         // Add OverloadResolutionPriority attribute only if priority > 0
@@ -454,6 +454,6 @@ private record AssertionExtensionData(
         INamedTypeSymbol AssertionBaseType,
         ImmutableArray<IMethodSymbol> Constructors,
         int OverloadResolutionPriority,
-        string? RequiresDynamicCodeMessage
+        string? RequiresUnreferencedCodeMessage
     );
 }

TUnit.Assertions/Conditions/Helpers/StructuralEqualityComparer.cs

@@ -10,7 +10,7 @@ namespace TUnit.Assertions.Conditions.Helpers;
 /// For complex objects, performs deep comparison of properties and fields.
 /// </summary>
 /// <typeparam name="T">The type of objects to compare</typeparam>
-[RequiresDynamicCode("Structural equality comparison uses reflection to access object members and is not compatible with AOT")]
+[RequiresUnreferencedCode("Structural equality comparison uses reflection to access object members and is not compatible with AOT")]
 public sealed class StructuralEqualityComparer<T> : IEqualityComparer<T>
 {
     /// <summary>

TUnit.Assertions/Conditions/IsEquivalentToAssertion.cs

@@ -14,7 +14,7 @@ namespace TUnit.Assertions.Conditions;
 /// Inherits from CollectionComparerBasedAssertion to preserve collection type awareness in And/Or chains.
 /// </summary>
 [AssertionExtension("IsEquivalentTo")]
-[RequiresDynamicCode("Collection equivalency uses structural comparison for complex objects, which requires reflection and is not compatible with AOT")]
+[RequiresUnreferencedCode("Collection equivalency uses structural comparison for complex objects, which requires reflection and is not compatible with AOT")]
 public class IsEquivalentToAssertion<TCollection, TItem> : CollectionComparerBasedAssertion<TCollection, TItem>
     where TCollection : IEnumerable<TItem>
 {

TUnit.Assertions/Conditions/NotEquivalentToAssertion.cs

@@ -13,7 +13,7 @@ namespace TUnit.Assertions.Conditions;
 /// Inherits from CollectionComparerBasedAssertion to preserve collection type awareness in And/Or chains.
 /// </summary>
 [AssertionExtension("IsNotEquivalentTo")]
-[RequiresDynamicCode("Collection equivalency uses structural comparison for complex objects, which requires reflection and is not compatible with AOT")]
+[RequiresUnreferencedCode("Collection equivalency uses structural comparison for complex objects, which requires reflection and is not compatible with AOT")]
 public class NotEquivalentToAssertion<TCollection, TItem> : CollectionComparerBasedAssertion<TCollection, TItem>
     where TCollection : IEnumerable<TItem>
 {

TUnit.Assertions/Conditions/StructuralEquivalencyAssertion.cs

@@ -10,6 +10,7 @@ namespace TUnit.Assertions.Conditions;
 /// Asserts that two objects are structurally equivalent by comparing their properties and fields.
 /// Supports partial equivalency and member exclusion.
 /// </summary>
+[RequiresUnreferencedCode("Uses reflection to compare object properties and fields.")]
 public class StructuralEquivalencyAssertion<TValue> : Assertion<TValue>
 {
     private readonly object? _expected;
@@ -166,9 +167,7 @@ internal AssertionResult CompareObjects(object? actual, object? expected, string
         }
 
         // Compare properties and fields
-#pragma warning disable IL2072 // GetType() does not preserve DynamicallyAccessedMembers - acceptable for runtime structural comparison
         var expectedMembers = GetMembersToCompare(expectedType);
-#pragma warning restore IL2072
 
         foreach (var member in expectedMembers)
         {
@@ -199,9 +198,7 @@ internal AssertionResult CompareObjects(object? actual, object? expected, string
             // In partial equivalency mode, skip members that don't exist on actual
             if (_usePartialEquivalency)
             {
-#pragma warning disable IL2072 // GetType() does not preserve DynamicallyAccessedMembers - acceptable for runtime structural comparison
                 var actualMember = GetMemberInfo(actualType, member.Name);
-#pragma warning restore IL2072
                 if (actualMember == null)
                 {
                     continue;
@@ -211,9 +208,7 @@ internal AssertionResult CompareObjects(object? actual, object? expected, string
             }
             else
             {
-#pragma warning disable IL2072 // GetType() does not preserve DynamicallyAccessedMembers - acceptable for runtime structural comparison
                 var actualMember = GetMemberInfo(actualType, member.Name);
-#pragma warning restore IL2072
                 if (actualMember == null)
                 {
                     return AssertionResult.Failed($"Property {memberPath} did not match{Environment.NewLine}Expected: {FormatValue(expectedValue)}{Environment.NewLine}Received: null");
@@ -231,9 +226,7 @@ internal AssertionResult CompareObjects(object? actual, object? expected, string
         // In non-partial mode, check for extra properties on actual
         if (!_usePartialEquivalency)
         {
-#pragma warning disable IL2072 // GetType() does not preserve DynamicallyAccessedMembers - acceptable for runtime structural comparison
             var actualMembers = GetMembersToCompare(actualType);
-#pragma warning restore IL2072
             var expectedMemberNames = new HashSet<string>(expectedMembers.Select(m => m.Name));
 
             foreach (var member in actualMembers)

TUnit.Core/AsyncConvert.cs

@@ -55,10 +55,7 @@ public static async ValueTask Convert(Func<Task> action)
                 | MethodImplOptions.AggressiveOptimization
 #endif
     )]
-    #if NET6_0_OR_GREATER
-    [RequiresUnreferencedCode("ConvertObject uses reflection to handle custom awaitable types and F# async. For AOT compatibility, use Task or ValueTask directly.")]
-    [RequiresDynamicCode("ConvertObject may require dynamic invocation for custom awaitable types. For AOT compatibility, use Task or ValueTask directly.")]
-    #endif
+
     public static async ValueTask ConvertObject(object? invoke)
     {
         if (invoke is Delegate @delegate)
@@ -116,17 +113,23 @@ public static async ValueTask ConvertObject(object? invoke)
         }
     }
 
-    [System.Diagnostics.CodeAnalysis.DynamicDependency(System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicMethods, "Microsoft.FSharp.Control.FSharpAsync", "FSharp.Core")]
-    [System.Diagnostics.CodeAnalysis.DynamicDependency("StartAsTask", "Microsoft.FSharp.Control.FSharpAsync", "FSharp.Core")]
-    #if NET6_0_OR_GREATER
-    [RequiresUnreferencedCode("F# async support requires FSharp.Core types and reflection. For AOT, use Task-based APIs.")]
-    [RequiresDynamicCode("F# async interop requires MakeGenericMethod. For AOT, use Task-based APIs.")]
-    #endif
+    [DynamicDependency(DynamicallyAccessedMemberTypes.PublicMethods, "Microsoft.FSharp.Control.FSharpAsync", "FSharp.Core")]
+    [DynamicDependency("StartAsTask", "Microsoft.FSharp.Control.FSharpAsync", "FSharp.Core")]
+    [UnconditionalSuppressMessage("Trimming", "IL2026:Members annotated with \'RequiresUnreferencedCodeAttribute\' require dynamic access otherwise can break functionality when trimming application code")]
+    [UnconditionalSuppressMessage("Trimming", "IL2060:Call to \'System.Reflection.MethodInfo.MakeGenericMethod\' can not be statically analyzed. It\'s not possible to guarantee the availability of requirements of the generic method.")]
+    [UnconditionalSuppressMessage("Trimming", "IL2072:Target parameter argument does not satisfy \'DynamicallyAccessedMembersAttribute\' in call to target method. The return value of the source method does not have matching annotations.")]
+    [UnconditionalSuppressMessage("Trimming", "IL2077:Target parameter argument does not satisfy \'DynamicallyAccessedMembersAttribute\' in call to target method. The source field does not have matching annotations.")]
+    [UnconditionalSuppressMessage("AOT", "IL3050:Calling members annotated with \'RequiresDynamicCodeAttribute\' may break functionality when AOT compiling.")]
     private static ValueTask StartAsFSharpTask(object invoke, Type type)
     {
         var startAsTaskOpenGenericMethod = (_fSharpAsyncType ??= type.Assembly.GetType("Microsoft.FSharp.Control.FSharpAsync"))!
             .GetRuntimeMethods()
-            .First(m => m.Name == "StartAsTask");
+            .FirstOrDefault(m => m.Name == "StartAsTask");
+
+        if (startAsTaskOpenGenericMethod is null)
+        {
+            return default;
+        }
 
         var fSharpTask = (Task) startAsTaskOpenGenericMethod.MakeGenericMethod(type.GetGenericArguments()[0])
             .Invoke(null, [invoke, null, null])!;
@@ -143,16 +146,11 @@ private static ValueTask StartAsFSharpTask(object invoke, Type type)
     /// <summary>
     /// Safely invokes F# async conversion with proper suppression for the call site.
     /// </summary>
-    #if NET6_0_OR_GREATER
-    [RequiresUnreferencedCode("F# async is an optional feature. AOT applications should use Task-based APIs.")]
-    [RequiresDynamicCode("F# async requires runtime code generation. This is documented as not AOT-compatible.")]
-    #endif
     private static async ValueTask StartAsFSharpTaskSafely(object invoke, Type type)
     {
         if (IsFSharpAsyncSupported())
         {
             await StartAsFSharpTask(invoke, type);
-            return;
         }
     }
 
@@ -181,10 +179,7 @@ private static bool IsFSharpAsyncSupported()
         }
     }
 
-    #if NET6_0_OR_GREATER
-    [RequiresUnreferencedCode("GetAwaiter pattern detection requires reflection for custom awaitable types. For AOT, use Task/ValueTask.")]
-    [RequiresDynamicCode("Custom awaitable handling may require dynamic invocation. For AOT, use Task/ValueTask.")]
-    #endif
+    [UnconditionalSuppressMessage("Trimming", "IL2075:\'this\' argument does not satisfy \'DynamicallyAccessedMembersAttribute\' in call to target method. The return value of the source method does not have matching annotations.")]
     public static bool TryGetAwaitableTask(object awaitable, [NotNullWhen(true)] out Task? task)
     {
         var getAwaiter = awaitable.GetType().GetMethod("GetAwaiter", Type.EmptyTypes);

TUnit.Core/Attributes/TestData/AsyncUntypedDataSourceSourceGeneratorAttribute.cs

@@ -3,10 +3,6 @@
 namespace TUnit.Core;
 
 [AttributeUsage(AttributeTargets.Method | AttributeTargets.Class | AttributeTargets.Property, AllowMultiple = true)]
-#if NET6_0_OR_GREATER
-[RequiresDynamicCode("AsyncUntypedDataSourceGeneratorAttribute requires dynamic code generation for runtime data source creation. Consider using strongly-typed AsyncDataSourceGeneratorAttribute<T> overloads for AOT compatibility.")]
-[RequiresUnreferencedCode("AsyncUntypedDataSourceGeneratorAttribute may require unreferenced code for runtime data source creation. Consider using strongly-typed AsyncDataSourceGeneratorAttribute<T> overloads for AOT compatibility.")]
-#endif
 public abstract class AsyncUntypedDataSourceGeneratorAttribute : Attribute, IAsyncUntypedDataSourceGeneratorAttribute
 {
     protected abstract IAsyncEnumerable<Func<Task<object?[]?>>> GenerateDataSourcesAsync(DataGeneratorMetadata dataGeneratorMetadata);