Generalize forwarding all property modifiers

Author: Sergio0694

src/CommunityToolkit.Mvvm.SourceGenerators/ComponentModel/Models/PropertyInfo.cs

@@ -15,6 +15,7 @@ namespace CommunityToolkit.Mvvm.SourceGenerators.ComponentModel.Models;
 /// <param name="TypeNameWithNullabilityAnnotations">The type name for the generated property, including nullability annotations.</param>
 /// <param name="FieldName">The field name.</param>
 /// <param name="PropertyName">The generated property name.</param>
+/// <param name="PropertyModifers">The list of additional modifiers for the property (they are <see cref="SyntaxKind"/> values).</param>
 /// <param name="PropertyAccessibility">The accessibility of the property.</param>
 /// <param name="GetterAccessibility">The accessibility of the <see langword="get"/> accessor.</param>
 /// <param name="SetterAccessibility">The accessibility of the <see langword="set"/> accessor.</param>
@@ -23,7 +24,6 @@ namespace CommunityToolkit.Mvvm.SourceGenerators.ComponentModel.Models;
 /// <param name="NotifiedCommandNames">The sequence of commands to notify.</param>
 /// <param name="NotifyPropertyChangedRecipients">Whether or not the generated property also broadcasts changes.</param>
 /// <param name="NotifyDataErrorInfo">Whether or not the generated property also validates its value.</param>
-/// <param name="IsRequired">Whether or not the generated property should be marked as required.</param>
 /// <param name="IsOldPropertyValueDirectlyReferenced">Whether the old property value is being directly referenced.</param>
 /// <param name="IsReferenceTypeOrUnconstrainedTypeParameter">Indicates whether the property is of a reference type or an unconstrained type parameter.</param>
 /// <param name="IncludeMemberNotNullOnSetAccessor">Indicates whether to include nullability annotations on the setter.</param>
@@ -34,6 +34,7 @@ internal sealed record PropertyInfo(
     string TypeNameWithNullabilityAnnotations,
     string FieldName,
     string PropertyName,
+    EquatableArray<ushort> PropertyModifers,
     Accessibility PropertyAccessibility,
     Accessibility GetterAccessibility,
     Accessibility SetterAccessibility,
@@ -42,7 +43,6 @@ internal sealed record PropertyInfo(
     EquatableArray<string> NotifiedCommandNames,
     bool NotifyPropertyChangedRecipients,
     bool NotifyDataErrorInfo,
-    bool IsRequired,
     bool IsOldPropertyValueDirectlyReferenced,
     bool IsReferenceTypeOrUnconstrainedTypeParameter,
     bool IncludeMemberNotNullOnSetAccessor,

src/CommunityToolkit.Mvvm.SourceGenerators/ComponentModel/ObservablePropertyGenerator.Execute.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.Collections.Immutable;
 using System.ComponentModel;
@@ -362,6 +363,9 @@ public static bool TryGetInfo(
 
             token.ThrowIfCancellationRequested();
 
+            // Get all additional modifiers for the member
+            ImmutableArray<SyntaxKind> propertyModifiers = GetPropertyModifiers(memberSyntax);
+
             // Retrieve the accessibility values for all components
             if (!TryGetAccessibilityModifiers(
                 memberSyntax,
@@ -388,6 +392,7 @@ public static bool TryGetInfo(
                 typeNameWithNullabilityAnnotations,
                 fieldName,
                 propertyName,
+                propertyModifiers.AsUnderlyingType(),
                 propertyAccessibility,
                 getterAccessibility,
                 setterAccessibility,
@@ -396,7 +401,6 @@ public static bool TryGetInfo(
                 notifiedCommandNames.ToImmutable(),
                 notifyRecipients,
                 notifyDataErrorInfo,
-                isRequired,
                 isOldPropertyValueDirectlyReferenced,
                 isReferenceTypeOrUnconstrainedTypeParameter,
                 includeMemberNotNullOnSetAccessor,
@@ -970,6 +974,45 @@ private static void GatherLegacyForwardedAttributes(
             }
         }
 
+        /// <summary>
+        /// Gathers all allowed property modifiers that should be forwarded to the generated property.
+        /// </summary>
+        /// <param name="memberSyntax">The <see cref="MemberDeclarationSyntax"/> instance to process.</param>
+        /// <returns>The returned set of property modifiers, if any.</returns>
+        private static ImmutableArray<SyntaxKind> GetPropertyModifiers(MemberDeclarationSyntax memberSyntax)
+        {
+            // Fields never need to carry additional modifiers along
+            if (memberSyntax.IsKind(SyntaxKind.FieldDeclaration))
+            {
+                return ImmutableArray<SyntaxKind>.Empty;
+            }
+
+            // We only allow a subset of all possible modifiers (aside from the accessibility modifiers)
+            ReadOnlySpan<SyntaxKind> candidateKinds =
+            [
+                SyntaxKind.NewKeyword,
+                SyntaxKind.VirtualKeyword,
+                SyntaxKind.SealedKeyword,
+                SyntaxKind.OverrideKeyword,
+#if ROSLYN_4_3_1_OR_GREATER
+                SyntaxKind.RequiredKeyword
+#endif
+            ];
+
+            using ImmutableArrayBuilder<SyntaxKind> builder = ImmutableArrayBuilder<SyntaxKind>.Rent();
+
+            // Track all modifiers from the allowed set on the input property declaration
+            foreach (SyntaxKind kind in candidateKinds)
+            {
+                if (memberSyntax.Modifiers.Any(kind))
+                {
+                    builder.Add(kind);
+                }
+            }
+
+            return builder.ToImmutable();
+        }
+
         /// <summary>
         /// Tries to get the accessibility of the property and accessors, if possible.
         /// If the target member is not a property, it will use the defaults.
@@ -1395,13 +1438,11 @@ private static SyntaxTokenList GetPropertyModifiers(PropertyInfo propertyInfo)
         {
             SyntaxTokenList propertyModifiers = propertyInfo.PropertyAccessibility.ToSyntaxTokenList();
 
-#if ROSLYN_4_3_1_OR_GREATER
-            // Add the 'required' modifier if the original member also had it
-            if (propertyInfo.IsRequired)
+            // Add all gathered modifiers
+            foreach (SyntaxKind modifier in propertyInfo.PropertyModifers.AsImmutableArray().FromUnderlyingType())
             {
-                propertyModifiers = propertyModifiers.Add(Token(SyntaxKind.RequiredKeyword));
+                propertyModifiers = propertyModifiers.Add(Token(modifier));
             }
-#endif
 
             // Add the 'partial' modifier if the original member is a partial property
             if (propertyInfo.AnnotatedMemberKind is SyntaxKind.PropertyDeclaration)

src/CommunityToolkit.Mvvm.SourceGenerators/Extensions/SyntaxKindExtensions.cs

@@ -3,6 +3,8 @@
 // See the LICENSE file in the project root for more information.
 
 using System;
+using System.Collections.Immutable;
+using System.Runtime.CompilerServices;
 using Microsoft.CodeAnalysis.CSharp;
 
 namespace CommunityToolkit.Mvvm.SourceGenerators.Extensions;
@@ -12,6 +14,30 @@ namespace CommunityToolkit.Mvvm.SourceGenerators.Extensions;
 /// </summary>
 internal static class SyntaxKindExtensions
 {
+    /// <summary>
+    /// Converts an <see cref="ImmutableArray{T}"/> of <see cref="SyntaxKind"/> values to one of their underlying type.
+    /// </summary>
+    /// <param name="array">The input <see cref="ImmutableArray{T}"/> value.</param>
+    /// <returns>The resulting <see cref="ImmutableArray{T}"/> of <see cref="ushort"/> values.</returns>
+    public static ImmutableArray<ushort> AsUnderlyingType(this ImmutableArray<SyntaxKind> array)
+    {
+        ushort[]? underlyingArray = (ushort[]?)(object?)Unsafe.As<ImmutableArray<SyntaxKind>, SyntaxKind[]?>(ref array);
+
+        return Unsafe.As<ushort[]?, ImmutableArray<ushort>>(ref underlyingArray);
+    }
+
+    /// <summary>
+    /// Converts an <see cref="ImmutableArray{T}"/> of <see cref="ushort"/> values to one of their real type.
+    /// </summary>
+    /// <param name="array">The input <see cref="ImmutableArray{T}"/> value.</param>
+    /// <returns>The resulting <see cref="ImmutableArray{T}"/> of <see cref="SyntaxKind"/> values.</returns>
+    public static ImmutableArray<SyntaxKind> FromUnderlyingType(this ImmutableArray<ushort> array)
+    {
+        SyntaxKind[]? typedArray = (SyntaxKind[]?)(object?)Unsafe.As<ImmutableArray<ushort>, ushort[]?>(ref array);
+
+        return Unsafe.As<SyntaxKind[]?, ImmutableArray<SyntaxKind>>(ref typedArray);
+    }
+
     /// <summary>
     /// Converts a <see cref="SyntaxKind"/> value to either "field" or "property" based on the kind.
     /// </summary>