Add SymbolInfoExtensions extensions, minor code tweaks

Author: Sergio0694

src/CommunityToolkit.Mvvm.SourceGenerators/CommunityToolkit.Mvvm.SourceGenerators.projitems

@@ -54,6 +54,7 @@
     <Compile Include="$(MSBuildThisFileDirectory)Extensions\INamedTypeSymbolExtensions.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Extensions\IncrementalGeneratorInitializationContextExtensions.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Extensions\IncrementalValuesProviderExtensions.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)Extensions\SymbolInfoExtensions.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Extensions\ISymbolExtensions.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Extensions\SourceProductionContextExtensions.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Extensions\ITypeSymbolExtensions.cs" />

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

@@ -214,12 +214,7 @@ public static bool TryGetInfo(
                     // 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);
-
-                    // Check if the attribute type can be resolved, and emit a diagnostic if that is not the case. This happens if eg. the
-                    // attribute type is spelled incorrectly, or if a user is missing the using directive for the attribute type being used.
-                    if ((attributeSymbolInfo.Symbol ?? attributeSymbolInfo.CandidateSymbols.SingleOrDefault()) is not ISymbol attributeSymbol ||
-                        (attributeSymbol as INamedTypeSymbol ?? attributeSymbol.ContainingType) is not INamedTypeSymbol attributeTypeSymbol)
+                    if (!semanticModel.GetSymbolInfo(attribute, token).TryGetAttributeTypeSymbol(out INamedTypeSymbol? attributeTypeSymbol))
                     {
                         builder.Add(
                             InvalidPropertyTargetedAttributeOnObservablePropertyField,

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

@@ -0,0 +1,41 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// 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.Diagnostics.CodeAnalysis;
+using System.Linq;
+using Microsoft.CodeAnalysis;
+
+namespace CommunityToolkit.Mvvm.SourceGenerators.Extensions;
+
+/// <summary>
+/// Extension methods for the <see cref="SymbolInfo"/> type.
+/// </summary>
+internal static class SymbolInfoExtensions
+{
+    /// <summary>
+    /// Tries to get the resolved attribute type symbol from a given <see cref="SymbolInfo"/> value.
+    /// </summary>
+    /// <param name="symbolInfo">The <see cref="SymbolInfo"/> value to check.</param>
+    /// <param name="typeSymbol">The resulting attribute type symbol, if correctly resolved.</param>
+    /// <returns>Whether <paramref name="symbolInfo"/> is resolved to a symbol.</returns>
+    /// <remarks>
+    /// This can be used to ensure users haven't eg. spelled names incorrecty or missed a using directive. Normally, code would just
+    /// not compile if that was the case, but that doesn't apply for attributes using invalid targets. In that case, Roslyn will ignore
+    /// any errors, meaning the generator has to validate the type symbols are correctly resolved on its own.
+    /// </remarks>
+    public static bool TryGetAttributeTypeSymbol(this SymbolInfo symbolInfo, [NotNullWhen(true)] out INamedTypeSymbol? typeSymbol)
+    {
+        if ((symbolInfo.Symbol ?? symbolInfo.CandidateSymbols.SingleOrDefault()) is not ISymbol attributeSymbol ||
+            (attributeSymbol as INamedTypeSymbol ?? attributeSymbol.ContainingType) is not INamedTypeSymbol resultingSymbol)
+        {
+            typeSymbol = null;
+
+            return false;
+        }
+
+        typeSymbol = resultingSymbol;
+
+        return true;
+    }
+}