Add more WinRT analyzers for class-level attributes

src/CommunityToolkit.Mvvm.SourceGenerators/AnalyzerReleases.Shipped.md

@@ -90,3 +90,5 @@ MVVMTK0045 | CommunityToolkit.Mvvm.SourceGenerators.ObservablePropertyGenerator
 MVVMTK0046 | CommunityToolkit.Mvvm.SourceGenerators.RelayCommandGenerator | Warning | See https://aka.ms/mvvmtoolkit/errors/mvvmtk0046
 MVVMTK0047 | CommunityToolkit.Mvvm.SourceGenerators.ObservablePropertyGenerator | Warning | See https://aka.ms/mvvmtoolkit/errors/mvvmtk0047
 MVVMTK0048 | CommunityToolkit.Mvvm.SourceGenerators.RelayCommandGenerator | Warning | See https://aka.ms/mvvmtoolkit/errors/mvvmtk0048
+MVVMTK0049 | CommunityToolkit.Mvvm.SourceGenerators.INotifyPropertyChangedGenerator | Warning | See https://aka.ms/mvvmtoolkit/errors/mvvmtk0049
+MVVMTK0050 | CommunityToolkit.Mvvm.SourceGenerators.ObservableObjectGenerator | Warning | See https://aka.ms/mvvmtoolkit/errors/mvvmtk0050

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

@@ -41,6 +41,7 @@
     <Compile Include="$(MSBuildThisFileDirectory)ComponentModel\TransitiveMembersGenerator.Execute.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Diagnostics\Analyzers\AsyncVoidReturningRelayCommandMethodAnalyzer.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Diagnostics\Analyzers\InvalidGeneratedPropertyObservablePropertyAttributeAnalyzer.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)Diagnostics\Analyzers\WinRTClassUsingNotifyPropertyChangedAttributesAnalyzer.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Diagnostics\Analyzers\WinRTGeneratedBindableCustomPropertyWithBasesMemberAnalyzer.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Diagnostics\Analyzers\WinRTRelayCommandIsNotGeneratedBindableCustomPropertyCompatibleAnalyzer.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Diagnostics\Analyzers\WinRTObservablePropertyOnFieldsIsNotAotCompatibleAnalyzer.cs" />

src/CommunityToolkit.Mvvm.SourceGenerators/ComponentModel/ObservableValidatorValidateAllPropertiesGenerator.cs

@@ -12,7 +12,7 @@
 namespace CommunityToolkit.Mvvm.SourceGenerators;
 
 /// <summary>
-/// A source generator for message registration without relying on compiled LINQ expressions.
+/// A source generator for property validation without relying on compiled LINQ expressions.
 /// </summary>
 [Generator(LanguageNames.CSharp)]
 public sealed partial class ObservableValidatorValidateAllPropertiesGenerator : IIncrementalGenerator

src/CommunityToolkit.Mvvm.SourceGenerators/Diagnostics/Analyzers/WinRTClassUsingNotifyPropertyChangedAttributesAnalyzer.cs

@@ -0,0 +1,89 @@
+// 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.Collections.Generic;
+using System.Collections.Immutable;
+using System.Linq;
+using CommunityToolkit.Mvvm.SourceGenerators.Extensions;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.Diagnostics;
+using static CommunityToolkit.Mvvm.SourceGenerators.Diagnostics.DiagnosticDescriptors;
+
+namespace CommunityToolkit.Mvvm.SourceGenerators;
+
+/// <summary>
+/// A diagnostic analyzer that generates a warning when <c>[ObservableObject]</c> and <c>[INotifyPropertyChanged]</c> are used on a class in WinRT scenarios.
+/// </summary>
+[DiagnosticAnalyzer(LanguageNames.CSharp)]
+public sealed class WinRTClassUsingNotifyPropertyChangedAttributesAnalyzer : DiagnosticAnalyzer
+{
+    /// <summary>
+    /// The mapping of target attributes that will trigger the analyzer.
+    /// </summary>
+    private static readonly ImmutableDictionary<string, string> GeneratorAttributeNamesToFullyQualifiedNamesMap = ImmutableDictionary.CreateRange(new[]
+    {
+        new KeyValuePair<string, string>("ObservableObjectAttribute", "CommunityToolkit.Mvvm.ComponentModel.ObservableObjectAttribute"),
+        new KeyValuePair<string, string>("INotifyPropertyChangedAttribute", "CommunityToolkit.Mvvm.ComponentModel.INotifyPropertyChangedAttribute"),
+    });
+
+    /// <summary>
+    /// The mapping of diagnostics for each target attribute.
+    /// </summary>
+    private static readonly ImmutableDictionary<string, DiagnosticDescriptor> GeneratorAttributeNamesToDiagnosticsMap = ImmutableDictionary.CreateRange(new[]
+    {
+        new KeyValuePair<string, DiagnosticDescriptor>("ObservableObjectAttribute", WinRTUsingObservableObjectAttribute),
+        new KeyValuePair<string, DiagnosticDescriptor>("INotifyPropertyChangedAttribute", WinRTUsingINotifyPropertyChangedAttribute),
+    });
+
+    /// <inheritdoc/>
+    public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics { get; } = ImmutableArray.Create(
+        WinRTUsingObservableObjectAttribute,
+        WinRTUsingINotifyPropertyChangedAttribute);
+
+    /// <inheritdoc/>
+    public override void Initialize(AnalysisContext context)
+    {
+        context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
+        context.EnableConcurrentExecution();
+
+        context.RegisterCompilationStartAction(static context =>
+        {
+            // This analyzer is only enabled when CsWinRT is in AOT mode
+            if (!context.Options.AnalyzerConfigOptionsProvider.GlobalOptions.IsCsWinRTAotOptimizerEnabled(context.Compilation))
+            {
+                return;
+            }
+
+            // Try to get all necessary type symbols
+            if (!context.Compilation.TryBuildNamedTypeSymbolMap(GeneratorAttributeNamesToFullyQualifiedNamesMap, out ImmutableDictionary<string, INamedTypeSymbol>? typeSymbols))
+            {
+                return;
+            }
+
+            context.RegisterSymbolAction(context =>
+            {
+                // We're looking for class declarations that don't have any base type (same as the other analyzer for non-WinRT scenarios), but inverted for base types.
+                // That is, we only want to warn in cases where the other analyzer would not warn. Otherwise, warnings from that one are already more than sufficient.
+                if (context.Symbol is not INamedTypeSymbol { TypeKind: TypeKind.Class, IsRecord: false, IsStatic: false, IsImplicitlyDeclared: false, BaseType.SpecialType: not SpecialType.System_Object } classSymbol)
+                {
+                    return;
+                }
+
+                foreach (AttributeData attribute in context.Symbol.GetAttributes())
+                {
+                    // Warn if either attribute is used, as it's not compatible with AOT
+                    if (attribute.AttributeClass is { Name: string attributeName } attributeClass &&
+                        typeSymbols.TryGetValue(attributeName, out INamedTypeSymbol? attributeSymbol) &&
+                        SymbolEqualityComparer.Default.Equals(attributeClass, attributeSymbol))
+                    {
+                        context.ReportDiagnostic(Diagnostic.Create(
+                            GeneratorAttributeNamesToDiagnosticsMap[attributeClass.Name],
+                            context.Symbol.Locations.FirstOrDefault(),
+                            context.Symbol));
+                    }
+                }
+            }, SymbolKind.NamedType);
+        });
+    }
+}

src/CommunityToolkit.Mvvm.SourceGenerators/Diagnostics/Analyzers/WinRTGeneratedBindableCustomPropertyWithBasesMemberAnalyzer.cs

@@ -38,7 +38,7 @@ public override void Initialize(AnalysisContext context)
                 return;
             }
 
-            // Get the symbol for [ObservableProperty], [RelayCommand] and [GeneratedBindableCustomProperty]
+            // Get the symbols for [ObservableProperty], [RelayCommand] and [GeneratedBindableCustomProperty]
             if (context.Compilation.GetTypeByMetadataName("CommunityToolkit.Mvvm.ComponentModel.ObservablePropertyAttribute") is not INamedTypeSymbol observablePropertySymbol ||
                 context.Compilation.GetTypeByMetadataName("CommunityToolkit.Mvvm.Input.RelayCommandAttribute") is not INamedTypeSymbol relayCommandSymbol ||
                 context.Compilation.GetTypeByMetadataName("WinRT.GeneratedBindableCustomPropertyAttribute") is not INamedTypeSymbol generatedBindableCustomPropertySymbol)

src/CommunityToolkit.Mvvm.SourceGenerators/Diagnostics/Analyzers/WinRTRelayCommandIsNotGeneratedBindableCustomPropertyCompatibleAnalyzer.cs

@@ -33,7 +33,7 @@ public override void Initialize(AnalysisContext context)
                 return;
             }
 
-            // Get the symbol for [RelayCommand] and [GeneratedBindableCustomProperty]
+            // Get the symbols for [RelayCommand] and [GeneratedBindableCustomProperty]
             if (context.Compilation.GetTypeByMetadataName("CommunityToolkit.Mvvm.Input.RelayCommandAttribute") is not INamedTypeSymbol relayCommandSymbol ||
                 context.Compilation.GetTypeByMetadataName("WinRT.GeneratedBindableCustomPropertyAttribute") is not INamedTypeSymbol generatedBindableCustomPropertySymbol)
             {

src/CommunityToolkit.Mvvm.SourceGenerators/Diagnostics/DiagnosticDescriptors.cs

@@ -812,4 +812,36 @@ internal static class DiagnosticDescriptors
         isEnabledByDefault: true,
         description: "Using [GeneratedBindableCustomProperty] on types that also use [RelayCommand] on any inherited methods is not supported, and a manually declared command property should be used instead (the [GeneratedBindableCustomProperty] generator cannot see the generated property that is produced by the MVVM Toolkit generator).",
         helpLinkUri: "https://aka.ms/mvvmtoolkit/errors/mvvmtk0048");
+
+    /// <summary>
+    /// Gets a <see cref="DiagnosticDescriptor"/> indicating when <c>[INotifyPropertyChanged]</c> is used on a type in WinRT scenarios.
+    /// <para>
+    /// Format: <c>"The type {0} is using the [INotifyPropertyChanged] attribute, with is not AOT compatible in WinRT scenarios (such as UWP XAML and WinUI 3 apps), and it should derive from ObservableObject or manually implement INotifyPropertyChanged instead (as it allows the CsWinRT generators to correctly produce the necessary WinRT marshalling code)"</c>.
+    /// </para>
+    /// </summary>
+    public static readonly DiagnosticDescriptor WinRTUsingINotifyPropertyChangedAttribute = new DiagnosticDescriptor(
+        id: "MVVMTK0049",
+        title: "Using [INotifyPropertyChanged] is not AOT compatible for WinRT",
+        messageFormat: "The type {0} is using the [INotifyPropertyChanged] attribute, with is not AOT compatible in WinRT scenarios (such as UWP XAML and WinUI 3 apps), and it should derive from ObservableObject or manually implement INotifyPropertyChanged instead (as it allows the CsWinRT generators to correctly produce the necessary WinRT marshalling code)",
+        category: typeof(INotifyPropertyChangedGenerator).FullName,
+        defaultSeverity: DiagnosticSeverity.Warning,
+        isEnabledByDefault: true,
+        description: "Using the [INotifyPropertyChanged] attribute on types is not AOT compatible in WinRT scenarios (such as UWP XAML and WinUI 3 apps), and they should derive from ObservableObject or manually implement INotifyPropertyChanged instead (as it allows the CsWinRT generators to correctly produce the necessary WinRT marshalling code).",
+        helpLinkUri: "https://aka.ms/mvvmtoolkit/errors/mvvmtk0049");
+
+    /// <summary>
+    /// Gets a <see cref="DiagnosticDescriptor"/> indicating when <c>[ObservableObject]</c> is used on a type in WinRT scenarios.
+    /// <para>
+    /// Format: <c>"The type {0} is using the [ObservableObject] attribute, with is not AOT compatible in WinRT scenarios (such as UWP XAML and WinUI 3 apps), and it should derive from ObservableObject instead (as it allows the CsWinRT generators to correctly produce the necessary WinRT marshalling code)"</c>.
+    /// </para>
+    /// </summary>
+    public static readonly DiagnosticDescriptor WinRTUsingObservableObjectAttribute = new DiagnosticDescriptor(
+        id: "MVVMTK0050",
+        title: "Using [ObservableObject] is not AOT compatible for WinRT",
+        messageFormat: "The type {0} is using the [ObservableObject] attribute, with is not AOT compatible in WinRT scenarios (such as UWP XAML and WinUI 3 apps), and it should derive from ObservableObject instead (as it allows the CsWinRT generators to correctly produce the necessary WinRT marshalling code)",
+        category: typeof(ObservableObjectGenerator).FullName,
+        defaultSeverity: DiagnosticSeverity.Warning,
+        isEnabledByDefault: true,
+        description: "Using the [ObservableObject] attribute on types is not AOT compatible in WinRT scenarios (such as UWP XAML and WinUI 3 apps), and they should derive from ObservableObject instead (as it allows the CsWinRT generators to correctly produce the necessary WinRT marshalling code).",
+        helpLinkUri: "https://aka.ms/mvvmtoolkit/errors/mvvmtk0050");
 }

tests/CommunityToolkit.Mvvm.SourceGenerators.Roslyn4110.UnitTests/Test_SourceGeneratorsDiagnostics.cs

@@ -503,89 +503,6 @@ await CSharpAnalyzerWithLanguageVersionTest<WinRTObservablePropertyOnFieldsIsNot
             editorconfig: [("_MvvmToolkitIsUsingWindowsRuntimePack", true), ("CsWinRTAotOptimizerEnabled", "true"), ("CsWinRTAotWarningLevel", 1)]);
     }
 
-    [TestMethod]
-    public async Task WinRTRelayCommandIsNotGeneratedBindableCustomPropertyCompatibleAnalyzer_NotTargetingWindows_DoesNotWarn()
-    {
-        const string source = """
-            using CommunityToolkit.Mvvm.ComponentModel;
-            using CommunityToolkit.Mvvm.Input;
-
-            namespace MyApp
-            {
-                public partial class SampleViewModel : ObservableObject
-                {            
-                    [RelayCommand]
-                    private void DoStuff()
-                    {
-                    }
-                }
-            }
-            """;
-
-        await CSharpAnalyzerWithLanguageVersionTest<WinRTRelayCommandIsNotGeneratedBindableCustomPropertyCompatibleAnalyzer>.VerifyAnalyzerAsync(
-            source,
-            LanguageVersion.CSharp12,
-            editorconfig: []);
-    }
-
-    [TestMethod]
-    public async Task WinRTRelayCommandIsNotGeneratedBindableCustomPropertyCompatibleAnalyzer_TargetingWindows_DoesNotWarn()
-    {
-        const string source = """
-            using CommunityToolkit.Mvvm.ComponentModel;
-            using CommunityToolkit.Mvvm.Input;
-
-            namespace MyApp
-            {
-                public partial class SampleViewModel : ObservableObject
-                {            
-                    [RelayCommand]
-                    private void DoStuff()
-                    {
-                    }
-                }
-            }
-            """;
-
-        await CSharpAnalyzerWithLanguageVersionTest<WinRTRelayCommandIsNotGeneratedBindableCustomPropertyCompatibleAnalyzer>.VerifyAnalyzerAsync(
-            source,
-            LanguageVersion.CSharp12,
-            editorconfig: [("_MvvmToolkitIsUsingWindowsRuntimePack", true)]);
-    }
-
-    [TestMethod]
-    public async Task WinRTRelayCommandIsNotGeneratedBindableCustomPropertyCompatibleAnalyzer_TargetingWindows_Bindable_Warns()
-    {
-        const string source = """
-            using System;
-            using CommunityToolkit.Mvvm.ComponentModel;
-            using CommunityToolkit.Mvvm.Input;
-            using WinRT;
-
-            namespace MyApp
-            {
-                [GeneratedBindableCustomProperty]
-                public partial class SampleViewModel : ObservableObject
-                {            
-                    [{|MVVMTK0046:RelayCommand|}]
-                    private void DoStuff()
-                    {
-                    }
-                }
-            }
-
-            namespace WinRT
-            {
-                public class GeneratedBindableCustomPropertyAttribute : Attribute;
-            }
-            """;
-
-        await CSharpAnalyzerWithLanguageVersionTest<WinRTRelayCommandIsNotGeneratedBindableCustomPropertyCompatibleAnalyzer>.VerifyAnalyzerAsync(
-            source,
-            LanguageVersion.CSharp12,
-            editorconfig: [("_MvvmToolkitIsUsingWindowsRuntimePack", true)]);
-    }
-
     [TestMethod]
     public async Task WinRTGeneratedBindableCustomPropertyWithBasesMemberAnalyzer_NotTargetingWindows_DoesNotWarn()
     {