Remove extra projection and comparer from ObservablePropertyGenerator

Author: Sergio0694

CommunityToolkit.Mvvm.SourceGenerators/ComponentModel/ObservablePropertyGenerator.cs

@@ -53,16 +53,14 @@ public void Initialize(IncrementalGeneratorInitializationContext context)
         context.ReportDiagnostics(propertyInfoWithErrors.Select(static (item, _) => item.Info.Errors));
 
         // Get the filtered sequence to enable caching
-        IncrementalValuesProvider<(HierarchyInfo Hierarchy, PropertyInfo Info)> propertyInfo =
+        IncrementalValuesProvider<(HierarchyInfo Hierarchy, Result<PropertyInfo> Info)> propertyInfo =
             propertyInfoWithErrors
-            .Select(static (item, _) => (item.Hierarchy, Info: item.Info.Value))
-            .Where(static item => item.Info is not null)!
-            .WithComparers(HierarchyInfo.Comparer.Default, PropertyInfo.Comparer.Default);
+            .Where(static item => item.Info.Value is not null)!;
 
         // Split and group by containing type
         IncrementalValuesProvider<(HierarchyInfo Hierarchy, ImmutableArray<PropertyInfo> Properties)> groupedPropertyInfo =
             propertyInfo
-            .GroupBy(HierarchyInfo.Comparer.Default)
+            .GroupBy(HierarchyInfo.Comparer.Default, static item => item.Value)
             .WithComparers(HierarchyInfo.Comparer.Default, PropertyInfo.Comparer.Default.ForImmutableArray());
 
         // Generate the requested properties and methods
@@ -84,7 +82,7 @@ public void Initialize(IncrementalGeneratorInitializationContext context)
         // Gather all property changing names
         IncrementalValueProvider<ImmutableArray<string>> propertyChangingNames =
             propertyInfo
-            .SelectMany(static (item, _) => item.Info.PropertyChangingNames)
+            .SelectMany(static (item, _) => item.Info.Value.PropertyChangingNames)
             .Collect()
             .Select(static (item, _) => item.Distinct().ToImmutableArray())
             .WithComparer(EqualityComparer<string>.Default.ForImmutableArray());
@@ -103,7 +101,7 @@ public void Initialize(IncrementalGeneratorInitializationContext context)
         // Gather all property changed names
         IncrementalValueProvider<ImmutableArray<string>> propertyChangedNames =
             propertyInfo
-            .SelectMany(static (item, _) => item.Info.PropertyChangedNames)
+            .SelectMany(static (item, _) => item.Info.Value.PropertyChangedNames)
             .Collect()
             .Select(static (item, _) => item.Distinct().ToImmutableArray())
             .WithComparer(EqualityComparer<string>.Default.ForImmutableArray());

CommunityToolkit.Mvvm.SourceGenerators/Extensions/IncrementalValuesProviderExtensions.cs

@@ -22,33 +22,36 @@ internal static class IncrementalValuesProviderExtensions
     /// </summary>
     /// <typeparam name="TLeft">The type of left items in each tuple.</typeparam>
     /// <typeparam name="TRight">The type of right items in each tuple.</typeparam>
+    /// <typeparam name="TElement">The type of resulting projected elements.</typeparam>
     /// <param name="source">The input <see cref="IncrementalValuesProvider{TValues}"/> instance.</param>
     /// <param name="comparer">A <typeparamref name="TLeft"/> comparer.</param>
+    /// <param name="projection">A projection function to convert gathered elements.</param>
     /// <returns>An <see cref="IncrementalValuesProvider{TValues}"/> with the grouped results.</returns>
-    public static IncrementalValuesProvider<(TLeft Left, ImmutableArray<TRight> Right)> GroupBy<TLeft, TRight>(
+    public static IncrementalValuesProvider<(TLeft Left, ImmutableArray<TElement> Right)> GroupBy<TLeft, TRight, TElement>(
         this IncrementalValuesProvider<(TLeft Left, TRight Right)> source,
-        IEqualityComparer<TLeft> comparer)
+        IEqualityComparer<TLeft> comparer,
+        Func<TRight, TElement> projection)
     {
         return source.Collect().SelectMany((item, _) =>
         {
-            Dictionary<TLeft, ImmutableArray<TRight>.Builder> map = new(comparer);
+            Dictionary<TLeft, ImmutableArray<TElement>.Builder> map = new(comparer);
 
             foreach ((TLeft hierarchy, TRight info) in item)
             {
-                if (!map.TryGetValue(hierarchy, out ImmutableArray<TRight>.Builder builder))
+                if (!map.TryGetValue(hierarchy, out ImmutableArray<TElement>.Builder builder))
                 {
-                    builder = ImmutableArray.CreateBuilder<TRight>();
+                    builder = ImmutableArray.CreateBuilder<TElement>();
 
                     map.Add(hierarchy, builder);
                 }
 
-                builder.Add(info);
+                builder.Add(projection(info));
             }
 
-            ImmutableArray<(TLeft Hierarchy, ImmutableArray<TRight> Properties)>.Builder result =
-                ImmutableArray.CreateBuilder<(TLeft, ImmutableArray<TRight>)>();
+            ImmutableArray<(TLeft Hierarchy, ImmutableArray<TElement> Elements)>.Builder result =
+                ImmutableArray.CreateBuilder<(TLeft, ImmutableArray<TElement>)>();
 
-            foreach (KeyValuePair<TLeft, ImmutableArray<TRight>.Builder> entry in map)
+            foreach (KeyValuePair<TLeft, ImmutableArray<TElement>.Builder> entry in map)
             {
                 result.Add((entry.Key, entry.Value.ToImmutable()));
             }