Merge pull request #261 from CommunityToolkit/dev/fix-build-errors-generic-generation-targets

Fix build errors with generic generation target types

Author: Sergio0694

CommunityToolkit.Mvvm.SourceGenerators/ComponentModel/ObservableValidatorValidateAllPropertiesGenerator.cs

@@ -28,7 +28,7 @@ public void Initialize(IncrementalGeneratorInitializationContext context)
             .CreateSyntaxProvider(
                 static (node, _) => node is ClassDeclarationSyntax,
                 static (context, _) => (context.Node, Symbol: (INamedTypeSymbol)context.SemanticModel.GetDeclaredSymbol(context.Node)!))
-            .Where(static item => !item.Symbol.IsAbstract && item.Node.IsFirstSyntaxDeclarationForSymbol(item.Symbol))
+            .Where(static item => item.Symbol is { IsAbstract: false, IsGenericType: false } && item.Node.IsFirstSyntaxDeclarationForSymbol(item.Symbol))
             .Select(static (item, _) => item.Symbol);
 
         // Get the types that inherit from ObservableValidator and gather their info

CommunityToolkit.Mvvm.SourceGenerators/Messaging/IMessengerRegisterAllGenerator.cs

@@ -31,7 +31,7 @@ public void Initialize(IncrementalGeneratorInitializationContext context)
             .CreateSyntaxProvider(
                 static (node, _) => node is ClassDeclarationSyntax,
                 static (context, _) => (context.Node, Symbol: (INamedTypeSymbol)context.SemanticModel.GetDeclaredSymbol(context.Node)!))
-            .Where(static item => !item.Symbol.IsAbstract && item.Node.IsFirstSyntaxDeclarationForSymbol(item.Symbol))
+            .Where(static item => item.Symbol is { IsAbstract: false, IsGenericType: false } && item.Node.IsFirstSyntaxDeclarationForSymbol(item.Symbol))
             .Select(static (item, _) => item.Symbol);
 
         // Get the target IRecipient<TMessage> interfaces and filter out other types

CommunityToolkit.Mvvm/ComponentModel/ObservableValidator.cs

@@ -606,8 +606,8 @@ where getMethod is not null
                 from property in validatableProperties
                 select Expression.Call(inst0, validateMethod, new Expression[]
                 {
-                        Expression.Convert(Expression.Call(inst0, property.GetMethod), typeof(object)),
-                        Expression.Constant(property.Name)
+                    Expression.Convert(Expression.Call(inst0, property.GetMethod), typeof(object)),
+                    Expression.Constant(property.Name)
                 }));
 
             return Expression.Lambda<Action<object>>(body, arg0).Compile();

tests/CommunityToolkit.Mvvm.UnitTests/Test_Messenger.cs

@@ -3,11 +3,13 @@
 // See the LICENSE file in the project root for more information.
 
 using System;
+using System.Collections.Generic;
 using System.Linq;
 using System.Reflection;
 using System.Threading;
 using System.Threading.Tasks;
 using CommunityToolkit.Mvvm.Messaging;
+using CommunityToolkit.Mvvm.Messaging.Messages;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 
 namespace CommunityToolkit.Mvvm.UnitTests;
@@ -372,6 +374,40 @@ public void Test_Messenger_IRecipient_SomeMessages_NoToken(Type type)
         Assert.IsFalse(messenger.IsRegistered<MessageB>(recipient));
     }
 
+    // See https://github.com/CommunityToolkit/dotnet/issues/198
+    [TestMethod]
+    [DataRow(typeof(StrongReferenceMessenger))]
+    [DataRow(typeof(WeakReferenceMessenger))]
+    public void Test_Messenger_IRecipient_SomeMessages_WithGenericTypeParameters(Type type)
+    {
+        IMessenger? messenger = (IMessenger)Activator.CreateInstance(type)!;
+        GenericRecipient<string> recipient = new();
+
+        messenger.RegisterAll(recipient);
+
+        Assert.IsTrue(messenger.IsRegistered<GenericRecipient<string>.Message>(recipient));
+        Assert.IsTrue(messenger.IsRegistered<ValueChangedMessage<string>>(recipient));
+        Assert.IsTrue(messenger.IsRegistered<MessageA>(recipient));
+
+        Assert.IsNull(recipient.ReceivedMessage1);
+        Assert.IsNull(recipient.ReceivedMessage2);
+        Assert.IsNull(recipient.ReceivedMessage3);
+
+        GenericRecipient<string>.Message message1 = messenger.Send(new GenericRecipient<string>.Message(new List<string> { "Hello world!" }));
+        ValueChangedMessage<string> message2 = messenger.Send(new ValueChangedMessage<string>("Hello"));
+        MessageA message3 = messenger.Send<MessageA>();
+
+        Assert.AreSame(recipient.ReceivedMessage1, message1);
+        Assert.AreSame(recipient.ReceivedMessage2, message2);
+        Assert.AreSame(recipient.ReceivedMessage3, message3);
+
+        messenger.UnregisterAll(recipient);
+
+        Assert.IsFalse(messenger.IsRegistered<GenericRecipient<string>.Message>(recipient));
+        Assert.IsFalse(messenger.IsRegistered<ValueChangedMessage<string>>(recipient));
+        Assert.IsFalse(messenger.IsRegistered<MessageA>(recipient));
+    }
+
     [TestMethod]
     [DataRow(typeof(StrongReferenceMessenger))]
     [DataRow(typeof(WeakReferenceMessenger))]
@@ -1059,4 +1095,36 @@ public sealed class MessageA
     public sealed class MessageB
     {
     }
+
+    public partial class GenericRecipient<T> : IRecipient<GenericRecipient<T>.Message>, IRecipient<ValueChangedMessage<T>>, IRecipient<MessageA>
+    {
+        public Message? ReceivedMessage1 { get; private set; }
+
+        public ValueChangedMessage<T>? ReceivedMessage2 { get; private set; }
+
+        public MessageA? ReceivedMessage3 { get; private set; }
+
+        public void Receive(Message message)
+        {
+            ReceivedMessage1 = message;
+        }
+
+        public void Receive(ValueChangedMessage<T> message)
+        {
+            ReceivedMessage2 = message;
+        }
+
+        public void Receive(MessageA message)
+        {
+            ReceivedMessage3 = message;
+        }
+
+        public sealed class Message : ValueChangedMessage<List<T>>
+        {
+            public Message(List<T> list)
+                : base(list)
+            {
+            }
+        }
+    }
 }

tests/CommunityToolkit.Mvvm.UnitTests/Test_ObservableValidator.cs

@@ -539,6 +539,32 @@ public void Test_ObservableRecipient_AbstractTypesDoNotTriggerCodeGeneration()
         Assert.IsNull(createAllPropertiesValidatorMethod);
     }
 
+    // See https://github.com/CommunityToolkit/dotnet/issues/246
+    [TestMethod]
+    public void Test_ObservableValidator_WithGenericTypeParameters()
+    {
+        GenericPerson<string> model = new();
+
+        model.Name = "Bob";
+
+        model.ValidateAllProperties();
+
+        Assert.IsTrue(model.HasErrors);
+
+        ValidationResult[] errors = model.GetErrors(nameof(model.Value)).ToArray();
+
+        Assert.IsNotNull(errors);
+        Assert.AreEqual(errors.Length, 1);
+
+        CollectionAssert.AreEqual(errors[0].MemberNames.ToArray(), new[] { nameof(model.Value) });
+
+        model.Value = "Ross";
+
+        model.ValidateAllProperties();
+
+        Assert.IsFalse(model.HasErrors);
+    }
+
     public class Person : ObservableValidator
     {
         private string? name;
@@ -797,4 +823,19 @@ public abstract class AbstractModelWithValidatableProperty : ObservableValidator
         [MinLength(2)]
         public string? Name { get; set; }
     }
+
+    public class GenericPerson<T> : ObservableValidator
+    {
+        [Required]
+        [MinLength(1)]
+        public string? Name { get; set; }
+
+        [Required]
+        public T? Value { get; set; }
+
+        public new void ValidateAllProperties()
+        {
+            base.ValidateAllProperties();
+        }
+    }
 }