+semver:minor - Improve AOT annotations + Various fixes (#3485)

* refactor(formatting): escape dots in strings to prevent namespace interpretation in VS Test Explorer

* test(aot): add tests for AOT compatibility with enum arguments to prevent IL3050 warnings

* refactor(assertions): simplify assertion calls by removing unnecessary casts

* refactor(matrix): streamline enum handling and remove unnecessary dynamic code attributes

* refactor(attributes): replace RequiresDynamicCode with RequiresUnreferencedCode for AOT compatibility

* test(aot): enhance AOT compatibility with property injection and dynamic test handling

* refactor(tests): remove unused methods and improve AOT compatibility annotations

* chore(dependencies): update TUnit package version to 0.75.38-PullRequest3485.0

* refactor(attributes): skip compiler-internal attributes during attribute processing

* refactor(PropertyInjection): use non-nullable type names for improved clarity

* refactor(CastHelper): remove unnecessary suppress message for AOT compilation

* refactor(CastHelper): simplify casting logic by removing unnecessary suppress messages and redundant code

* refactor(CastHelper): enhance casting logic with AOT-safe conversions and improved type handling

* refactor(CastHelper): optimize casting method by adding direct type check for improved performance

* refactor(CastHelper): improve AOT handling in TryReflectionConversion method to skip reflection-based conversions in AOT mode

* feat: enhance AOT converter by scanning for conversion operators in source code and referenced assemblies

* feat: improve AOT converter by scanning all types in compilation for conversion operators

* feat: add support for scanning closed generic types in method parameters for conversion operators

* feat: add AOT and single file publishing steps to CI pipeline

* feat: update TUnit package version references to use TUnitVersion variable

* feat: add additional suppression message for trimming in reflection mode

* feat: introduce IMemberMetadata interface and update related metadata classes

* fix: refine DynamicallyAccessedMembers attributes in Cast methods for AOT compatibility

* fix: update DynamicallyAccessedMembers attributes in Cast methods for improved AOT compatibility

Author: thomhurst

.github/workflows/dotnet.yml

@@ -66,6 +66,12 @@ jobs:
       - name: Build
         run: dotnet build -c Release
 
+      - name: Publish AOT
+        run: dotnet publish TUnit.TestProject/TUnit.TestProject.csproj -c Release --use-current-runtime -p:Aot=true -o TESTPROJECT_AOT --framework net8.0
+
+      - name: Publish Single File
+        run: dotnet publish TUnit.TestProject/TUnit.TestProject.csproj -c Release --use-current-runtime -p:SingleFile=true -o TESTPROJECT_SINGLEFILE --framework net8.0
+
       - name: Run Pipeline
         uses: ./.github/actions/execute-pipeline
         with:

Directory.Packages.props

@@ -80,6 +80,7 @@
     <PackageVersion Include="Testcontainers.PostgreSql" Version="4.8.1" />
     <PackageVersion Include="Testcontainers.Redis" Version="4.8.1" />
     <PackageVersion Include="trxparser" Version="0.5.0" />
+    <PackageVersion Include="TUnit.Assertions.FSharp" Version="0.75.38-PullRequest3485.0" />
     <PackageVersion Include="Verify" Version="31.0.4" />
     <PackageVersion Include="Verify.NUnit" Version="31.0.4" />
     <PackageVersion Include="TUnit" Version="0.75.30" />

TUnit.Analyzers/AnalyzerReleases.Unshipped.md

@@ -1,5 +1,4 @@
 ### New Rules
 
-Rule ID | Category | Severity | Notes 
---------|----------|----------|-------
-TUnit0052 | Usage | Warning | Multiple constructors found without [TestConstructor] attribute
+Rule ID | Category | Severity | Notes
+--------|----------|----------|-------

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.Tests/DictionaryCollectionTests.cs

@@ -184,7 +184,7 @@ public async Task Dictionary_IsEquivalentTo_Works()
         // IsEquivalentTo works on collections regardless of order
         // Cast both to IEnumerable to use collection equivalency
         await Assert.That((IEnumerable<KeyValuePair<string, int>>)dictionary1)
-            .IsEquivalentTo((IEnumerable<KeyValuePair<string, int>>)dictionary2);
+            .IsEquivalentTo(dictionary2);
     }
 
     [Test]

TUnit.Assertions.Tests/Old/DictionaryAssertionTests.cs

@@ -32,7 +32,7 @@ public async Task String_ReadOnlyDictionary_Contains_Key()
     {
         var dictionary = new ReadDictionary();
 
-        await TUnitAssert.That((IReadOnlyDictionary<string, string>)dictionary).ContainsKey("Blah");
+        await TUnitAssert.That(dictionary).ContainsKey("Blah");
     }
 
     [Test]

TUnit.Assertions.Tests/Old/EquivalentAssertionTests.cs

@@ -98,7 +98,7 @@ public async Task Different_Dictionaries_Are_Equivalent_With_Different_Ordered_K
         // Dictionaries are equivalent regardless of key order by default
         // Cast both to IEnumerable to use collection equivalency
         await TUnitAssert.That((IEnumerable<KeyValuePair<string, string>>)dict1)
-            .IsEquivalentTo((IEnumerable<KeyValuePair<string, string>>)dict2);
+            .IsEquivalentTo(dict2);
     }
 
     [Test]

TUnit.Assertions.Tests/TypeOfTests.cs

@@ -242,7 +242,7 @@ public async Task CollectionAssertion_NullableByteArray_CanUseCollectionMethods(
 
         // Should be able to use collection assertion methods
         await Assert.That(nullableBytes).HasCount(5);
-        await Assert.That(nullableBytes).Contains((byte)3);
+        await Assert.That(nullableBytes).Contains(3);
         await Assert.That(nullableBytes).IsInOrder();
 
     }

TUnit.Assertions/Assertions/Enums/EnumAssertions.cs

@@ -30,8 +30,8 @@ protected override Task<AssertionResult> CheckAsync(EvaluationMetadata<TEnum> me
         }
 
         // Use HasFlag method for enum flag checking
-        var enumValue = (Enum)(object)value;
-        var enumFlag = (Enum)(object)_expectedFlag;
+        var enumValue = (Enum)value;
+        var enumFlag = (Enum)_expectedFlag;
 
         if (enumValue.HasFlag(enumFlag))
         {
@@ -70,8 +70,8 @@ protected override Task<AssertionResult> CheckAsync(EvaluationMetadata<TEnum> me
             return Task.FromResult(AssertionResult.Failed($"threw {exception.GetType().Name}: {exception.Message}"));
         }
 
-        var enumValue = (Enum)(object)value;
-        var enumFlag = (Enum)(object)_unexpectedFlag;
+        var enumValue = (Enum)value;
+        var enumFlag = (Enum)_unexpectedFlag;
 
         if (!enumValue.HasFlag(enumFlag))
         {
@@ -106,7 +106,11 @@ protected override Task<AssertionResult> CheckAsync(EvaluationMetadata<TEnum> me
             return Task.FromResult(AssertionResult.Failed($"threw {exception.GetType().Name}: {exception.Message}"));
         }
 
+#if NET
+        if (Enum.IsDefined(value))
+#else
         if (Enum.IsDefined(typeof(TEnum), value))
+#endif
         {
             return Task.FromResult(AssertionResult.Passed);
         }
@@ -139,7 +143,11 @@ protected override Task<AssertionResult> CheckAsync(EvaluationMetadata<TEnum> me
             return Task.FromResult(AssertionResult.Failed($"threw {exception.GetType().Name}: {exception.Message}"));
         }
 
+#if NET
+        if (!Enum.IsDefined(value))
+#else
         if (!Enum.IsDefined(typeof(TEnum), value))
+#endif
         {
             return Task.FromResult(AssertionResult.Passed);
         }

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>