Remove trimming annoations for [ObservableRecipient] on older runtimes

Author: Sergio0694

CommunityToolkit.Mvvm.SourceGenerators/ComponentModel/Models/ObservableRecipientInfo.cs

@@ -11,8 +11,10 @@ namespace CommunityToolkit.Mvvm.SourceGenerators.ComponentModel.Models;
 /// <param name="HasExplicitConstructors">Whether or not the target type has explicit constructors.</param>
 /// <param name="IsAbstract">Whether or not the target type is abstract.</param>
 /// <param name="IsObservableValidator">Whether or not the target type inherits from <c>ObservableValidator</c>.</param>
+/// <param name="IsRequiresUnreferencedCodeAttributeAvailable">Whether or not the <c>RequiresUnreferencedCodeAttribute</c> type is available.</param>
 public sealed record ObservableRecipientInfo(
     string TypeName,
     bool HasExplicitConstructors,
     bool IsAbstract,
-    bool IsObservableValidator);
+    bool IsObservableValidator,
+    bool IsRequiresUnreferencedCodeAttributeAvailable);

CommunityToolkit.Mvvm.SourceGenerators/ComponentModel/ObservableRecipientGenerator.cs

@@ -34,7 +34,7 @@ public ObservableRecipientGenerator()
         IncrementalGeneratorInitializationContext context,
         IncrementalValuesProvider<(INamedTypeSymbol Symbol, AttributeData AttributeData)> source)
     {
-        static ObservableRecipientInfo GetInfo(INamedTypeSymbol typeSymbol, AttributeData attributeData)
+        static ObservableRecipientInfo GetInfo(INamedTypeSymbol typeSymbol, AttributeData attributeData, bool isRequiresUnreferencedCodeAttributeAvailable)
         {
             string typeName = typeSymbol.Name;
             bool hasExplicitConstructors = !(typeSymbol.InstanceConstructors.Length == 1 && typeSymbol.InstanceConstructors[0] is { Parameters.IsEmpty: true, IsImplicitlyDeclared: true });
@@ -45,10 +45,19 @@ static ObservableRecipientInfo GetInfo(INamedTypeSymbol typeSymbol, AttributeDat
                 typeName,
                 hasExplicitConstructors,
                 isAbstract,
-                isObservableValidator);
+                isObservableValidator,
+                isRequiresUnreferencedCodeAttributeAvailable);
         }
 
-        return source.Select(static (item, _) => (item.Symbol, GetInfo(item.Symbol, item.AttributeData)));
+        // Check whether [RequiresUnreferencedCode] is available
+        IncrementalValueProvider<bool> isRequiresUnreferencedCodeAttributeAvailable =
+            context.CompilationProvider
+            .Select(static (item, _) => item.GetTypeByMetadataName("System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute") is not null);
+
+        return
+            source
+            .Combine(isRequiresUnreferencedCodeAttributeAvailable)
+            .Select(static (item, _) => (item.Left.Symbol, GetInfo(item.Left.Symbol, item.Left.AttributeData, item.Right)));
     }
 
     /// <inheritdoc/>
@@ -110,14 +119,31 @@ protected override ImmutableArray<MemberDeclarationSyntax> FilterDeclaredMembers
             }
         }
 
+        MemberDeclarationSyntax RemoveRequiresUnreferencedCodeAttributeIfNeeded(MemberDeclarationSyntax member)
+        {
+            if (!info.IsRequiresUnreferencedCodeAttributeAvailable &&
+                member is PropertyDeclarationSyntax { Identifier.ValueText: "IsActive" } or MethodDeclarationSyntax { Identifier.ValueText: "OnActivated" })
+            {
+                SyntaxNode attributeNode =
+                    member
+                    .DescendantNodes()
+                    .OfType<AttributeListSyntax>()
+                    .First(node => ((IdentifierNameSyntax)((QualifiedNameSyntax)node.Attributes[0].Name).Right).Identifier.ValueText == "RequiresUnreferencedCode");
+
+                return member.RemoveNode(attributeNode, SyntaxRemoveOptions.KeepExteriorTrivia)!;
+            }
+
+            return member;
+        }
+
         // Skip the SetProperty overloads if the target type inherits from ObservableValidator, to avoid conflicts
         if (info.IsObservableValidator)
         {
             foreach (MemberDeclarationSyntax member in memberDeclarations.Where(static member => member is not ConstructorDeclarationSyntax))
             {
                 if (member is not MethodDeclarationSyntax { Identifier.ValueText: "SetProperty" })
                 {
-                    builder.Add(member);
+                    builder.Add(RemoveRequiresUnreferencedCodeAttributeIfNeeded(member));
                 }
             }
 
@@ -127,7 +153,7 @@ protected override ImmutableArray<MemberDeclarationSyntax> FilterDeclaredMembers
         // If the target type has at least one custom constructor, only generate methods
         foreach (MemberDeclarationSyntax member in memberDeclarations.Where(static member => member is not ConstructorDeclarationSyntax))
         {
-            builder.Add(member);
+            builder.Add(RemoveRequiresUnreferencedCodeAttributeIfNeeded(member));
         }
 
         return builder.ToImmutable();

tests/CommunityToolkit.Mvvm.UnitTests/Test_ObservableRecipientAttribute.cs

@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
+using System;
 using System.Collections.Generic;
 using System.ComponentModel;
 using System.ComponentModel.DataAnnotations;
@@ -97,4 +98,59 @@ public void Test_ObservableRecipientAttribute_NonAbstractConstructors()
     public partial class NonAbstractPerson : ObservableObject
     {
     }
+
+    [TestMethod]
+    public void Test_ObservableRecipientAttribute_TrimmingAnnoations_IsActive()
+    {
+        bool shouldHaveTrimmingAnnotations =
+#if NET6_0_OR_GREATER
+            true;
+#else
+            false;
+#endif
+
+        MethodInfo isActivePropertySetter = typeof(TestRecipient).GetProperty(nameof(TestRecipient.IsActive))!.SetMethod!;
+
+        if (shouldHaveTrimmingAnnotations)
+        {
+            Attribute[] attributes = isActivePropertySetter.GetCustomAttributes().ToArray();
+
+            Assert.AreEqual(1, attributes.Length);
+            Assert.AreEqual("System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute", attributes[0].GetType().ToString());
+        }
+        else
+        {
+            Attribute[] attributes = isActivePropertySetter.GetCustomAttributes().ToArray();
+
+            Assert.AreEqual(0, attributes.Length);
+        }
+    }
+
+    [TestMethod]
+    public void Test_ObservableRecipientAttribute_TrimmingAnnoations_OnActivated()
+    {
+        bool shouldHaveTrimmingAnnotations =
+#if NET6_0_OR_GREATER
+            true;
+#else
+            false;
+#endif
+
+        MethodInfo onActivatedMethod = typeof(TestRecipient).GetMethod("OnActivated", BindingFlags.Instance | BindingFlags.NonPublic)!;
+        IEnumerable<Attribute> attributes = onActivatedMethod.GetCustomAttributes();
+
+        if (shouldHaveTrimmingAnnotations)
+        {
+            Assert.IsTrue(attributes.Any(static a => a.GetType().ToString() == "System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute"));
+        }
+        else
+        {
+            Assert.IsFalse(attributes.Any(static a => a.GetType().ToString() == "System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute"));
+        }
+    }
+
+    [ObservableRecipient]
+    public abstract partial class TestRecipient : ObservableObject
+    {
+    }
 }