Initial draft of forwarded explicit property attributes

Author: Sergio0694

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

@@ -6,6 +6,7 @@
 using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Linq;
+using System.Threading;
 using CommunityToolkit.Mvvm.SourceGenerators.Extensions;
 using CommunityToolkit.Mvvm.SourceGenerators.Helpers;
 using Microsoft.CodeAnalysis;
@@ -51,6 +52,49 @@ public static AttributeInfo From(AttributeData attributeData)
             namedArguments.ToImmutable());
     }
 
+    /// <summary>
+    /// Creates a new <see cref="AttributeInfo"/> instance from a given syntax node.
+    /// </summary>
+    /// <param name="typeSymbol">The symbol for the attribute type.</param>
+    /// <param name="semanticModel">The <see cref="SemanticModel"/> instance for the current run.</param>
+    /// <param name="arguments">The sequence of <see cref="AttributeArgumentSyntax"/> instances to process.</param>
+    /// <param name="token">The cancellation token for the current operation.</param>
+    /// <returns>A <see cref="AttributeInfo"/> instance representing the input attribute data.</returns>
+    public static AttributeInfo From(INamedTypeSymbol typeSymbol, SemanticModel semanticModel, IEnumerable<AttributeArgumentSyntax> arguments, CancellationToken token)
+    {
+        string typeName = typeSymbol.GetFullyQualifiedName();
+
+        ImmutableArray<TypedConstantInfo>.Builder constructorArguments = ImmutableArray.CreateBuilder<TypedConstantInfo>();
+        ImmutableArray<(string, TypedConstantInfo)>.Builder namedArguments = ImmutableArray.CreateBuilder<(string, TypedConstantInfo)>();
+
+        foreach (AttributeArgumentSyntax argument in arguments)
+        {
+            // The attribute expression has to have an available operation to extract information from
+            if (semanticModel.GetOperation(argument.Expression, token) is not IOperation operation)
+            {
+                continue;
+            }
+
+            TypedConstantInfo argumentInfo = TypedConstantInfo.From(operation);
+
+            // Try to get the identifier name if the current expression is a named argument expression. If it
+            // isn't, then the expression is a normal attribute constructor argument, so no extra work is needed.
+            if (argument.NameEquals is { Name.Identifier.ValueText: string argumentName })
+            {
+                namedArguments.Add((argumentName, argumentInfo));
+            }
+            else
+            {
+                constructorArguments.Add(argumentInfo);
+            }
+        }
+
+        return new(
+            typeName,
+            constructorArguments.ToImmutable(),
+            namedArguments.ToImmutable());
+    }
+
     /// <summary>
     /// Gets an <see cref="AttributeSyntax"/> instance representing the current value.
     /// </summary>

CommunityToolkit.Mvvm.SourceGenerators/ComponentModel/Models/TypedConstantInfo.Factory.cs

@@ -6,6 +6,7 @@
 using System.Collections.Immutable;
 using System.Linq;
 using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.Operations;
 
 namespace CommunityToolkit.Mvvm.SourceGenerators.ComponentModel.Models;
 
@@ -57,4 +58,61 @@ public static TypedConstantInfo From(TypedConstant arg)
             _ => throw new ArgumentException("Invalid typed constant type"),
         };
     }
+
+    /// <summary>
+    /// Creates a new <see cref="TypedConstantInfo"/> instance from a given <see cref="IOperation"/> value.
+    /// </summary>
+    /// <param name="arg">The input <see cref="IOperation"/> value.</param>
+    /// <returns>A <see cref="TypedConstantInfo"/> instance representing <paramref name="arg"/>.</returns>
+    /// <exception cref="ArgumentException">Thrown if the input argument is not valid.</exception>
+    public static TypedConstantInfo From(IOperation arg)
+    {
+        if (arg.ConstantValue.HasValue)
+        {
+            // Enum values are constant but need to be checked explicitly in this case
+            if (arg.Type?.TypeKind is TypeKind.Enum)
+            {
+                return new Enum(arg.Type!.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat), arg.ConstantValue.Value!);
+            }
+
+            // Handle all other constant literals normally
+            return arg.ConstantValue.Value switch
+            {
+                null => new Null(),
+                string text => new Primitive.String(text),
+                bool flag => new Primitive.Boolean(flag),
+                byte b => new Primitive.Of<byte>(b),
+                char c => new Primitive.Of<char>(c),
+                double d => new Primitive.Of<double>(d),
+                float f => new Primitive.Of<float>(f),
+                int i => new Primitive.Of<int>(i),
+                long l => new Primitive.Of<long>(l),
+                sbyte sb => new Primitive.Of<sbyte>(sb),
+                short sh => new Primitive.Of<short>(sh),
+                uint ui => new Primitive.Of<uint>(ui),
+                ulong ul => new Primitive.Of<ulong>(ul),
+                ushort ush => new Primitive.Of<ushort>(ush),
+                _ => throw new ArgumentException("Invalid primitive type")
+            };
+        }
+
+        if (arg is ITypeOfOperation typeOfOperation)
+        {
+            return new Type(typeOfOperation.TypeOperand.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat));
+        }
+
+        if (arg is IArrayCreationOperation arrayCreationOperation)
+        {
+            string? elementTypeName = ((IArrayTypeSymbol?)arg.Type)?.ElementType.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat);
+
+            // If the element type is not available (since the attribute wasn't checked), just default to object
+            elementTypeName ??= "object";
+
+            ImmutableArray<TypedConstantInfo> items = ImmutableArray<TypedConstantInfo>.Empty; // TODO
+
+            return new Array(elementTypeName, items);
+        }
+
+        throw new ArgumentException("Invalid attribute argument value");
+    }
 }

CommunityToolkit.Mvvm.SourceGenerators/ComponentModel/ObservablePropertyGenerator.Execute.cs

@@ -6,6 +6,7 @@
 using System.ComponentModel;
 using System.Globalization;
 using System.Linq;
+using System.Threading;
 using CommunityToolkit.Mvvm.SourceGenerators.ComponentModel.Models;
 using CommunityToolkit.Mvvm.SourceGenerators.Diagnostics;
 using CommunityToolkit.Mvvm.SourceGenerators.Extensions;
@@ -28,10 +29,18 @@ internal static class Execute
         /// <summary>
         /// Processes a given field.
         /// </summary>
+        /// <param name="fieldSyntax">The <see cref="FieldDeclarationSyntax"/> instance to process.</param>
         /// <param name="fieldSymbol">The input <see cref="IFieldSymbol"/> instance to process.</param>
+        /// <param name="semanticModel">The <see cref="SemanticModel"/> instance for the current run.</param>
+        /// <param name="token">The cancellation token for the current operation.</param>
         /// <param name="diagnostics">The resulting diagnostics from the processing operation.</param>
         /// <returns>The resulting <see cref="PropertyInfo"/> instance for <paramref name="fieldSymbol"/>, if successful.</returns>
-        public static PropertyInfo? TryGetInfo(IFieldSymbol fieldSymbol, out ImmutableArray<Diagnostic> diagnostics)
+        public static PropertyInfo? TryGetInfo(
+            FieldDeclarationSyntax fieldSyntax,
+            IFieldSymbol fieldSymbol,
+            SemanticModel semanticModel,
+            CancellationToken token,
+            out ImmutableArray<Diagnostic> diagnostics)
         {
             ImmutableArray<Diagnostic>.Builder builder = ImmutableArray.CreateBuilder<Diagnostic>();
 
@@ -168,6 +177,45 @@ internal static class Execute
                 }
             }
 
+            // Gather explicit forwarded attributes info
+            foreach (AttributeListSyntax attributeList in fieldSyntax.AttributeLists)
+            {
+                // Only look for attribute lists explicitly targeting the (generated) property. Roslyn will normally emit a
+                // CS0657 warning (invalid target), but that is automatically suppressed by a dedicated diagnostic suppressor
+                // that recognizes uses of this target specifically to support [ObservableProperty].
+                if (attributeList.Target?.Identifier.Kind() is not SyntaxKind.PropertyKeyword)
+                {
+                    continue;
+                }
+
+                foreach (AttributeSyntax attribute in attributeList.Attributes)
+                {
+                    // Roslyn ignores attributes in an attribute list with an invalid target, so we can't get the AttributeData as usual.
+                    // To reconstruct all necessary attribute info to generate the serialized model, we use the following steps:
+                    //   - We try to get the attribute symbol from the semantic model, for the current attribute syntax. In case this is not
+                    //     available (in theory it shouldn't, but it can be), we try to get it from the candidate symbols list for the node.
+                    //     If there are no candidates or more than one, we just issue a diagnostic and stop processing the current attribute.
+                    //     The returned symbols might be method symbols (constructor attribute) so in that case we can get the declaring type.
+                    //   - We then go over each attribute argument expression and get the operation for it. This will still be available even
+                    //     though the rest of the attribute is not validated nor bound at all. From the operation we can still retrieve all
+                    //     constant values to build the AttributeInfo model. After all, attributes only support constant values, typeof(T)
+                    //     expressions, or arrays of either these two types, or of other arrays with the same rules, recursively.
+                    //   - From the syntax, we can also determine the identifier names for named attribute arguments, if any.
+                    // There is no need to validate anything here: the attribute will be forwarded as is, and then Roslyn will validate on the
+                    // generated property. Users will get the same validation they'd have had directly over the field. The only drawback is the
+                    // lack of IntelliSense when constructing attributes over the field, but this is the best we can do from this end anyway.
+                    SymbolInfo attributeSymbolInfo = semanticModel.GetSymbolInfo(attribute, token);
+
+                    if ((attributeSymbolInfo.Symbol ?? attributeSymbolInfo.CandidateSymbols.SingleOrDefault()) is not ISymbol attributeSymbol ||
+                        (attributeSymbol as INamedTypeSymbol ?? attributeSymbol.ContainingType) is not INamedTypeSymbol attributeTypeSymbol)
+                    {
+                        continue;
+                    }
+
+                    forwardedAttributes.Add(AttributeInfo.From(attributeTypeSymbol, semanticModel, attribute.ArgumentList?.Arguments ?? Enumerable.Empty<AttributeArgumentSyntax>(), token));
+                }
+            }
+
             // Log the diagnostic for missing ObservableValidator, if needed
             if (hasAnyValidationAttributes &&
                 !fieldSymbol.ContainingType.InheritsFromFullyQualifiedName("global::CommunityToolkit.Mvvm.ComponentModel.ObservableValidator"))

CommunityToolkit.Mvvm.SourceGenerators/ComponentModel/ObservablePropertyGenerator.cs

@@ -37,11 +37,12 @@ public void Initialize(IncrementalGeneratorInitializationContext context)
                         return default;
                     }
 
+                    FieldDeclarationSyntax fieldDeclaration = (FieldDeclarationSyntax)context.TargetNode.Parent!.Parent!;
                     IFieldSymbol fieldSymbol = (IFieldSymbol)context.TargetSymbol;
 
                     // Produce the incremental models
                     HierarchyInfo hierarchy = HierarchyInfo.From(fieldSymbol.ContainingType);
-                    PropertyInfo? propertyInfo = Execute.TryGetInfo(fieldSymbol, out ImmutableArray<Diagnostic> diagnostics);
+                    PropertyInfo? propertyInfo = Execute.TryGetInfo(fieldDeclaration, fieldSymbol, context.SemanticModel, token, out ImmutableArray<Diagnostic> diagnostics);
 
                     return (Hierarchy: hierarchy, new Result<PropertyInfo?>(propertyInfo, diagnostics));
                 })