Merge pull request #434 from CommunityToolkit/dev/orphaned-fields-analyzer

Sergio0694 · web-flow · commit 58762429501b · 2022-09-10T03:05:12.000+02:00
Move diagnostics for orphaned observable property attributes to analyzer
diff --git a/CommunityToolkit.Mvvm.SourceGenerators/ComponentModel/ObservablePropertyGenerator.Execute.cs b/CommunityToolkit.Mvvm.SourceGenerators/ComponentModel/ObservablePropertyGenerator.Execute.cs
@@ -204,19 +204,6 @@ internal static class Execute
                 forwardedAttributes.ToImmutable());
         }
 
-        /// <summary>
-        /// Gets the diagnostics for a field with invalid attribute uses.
-        /// </summary>
-        /// <param name="fieldSymbol">The input <see cref="IFieldSymbol"/> instance to process.</param>
-        /// <returns>The resulting <see cref="Diagnostic"/> instance for <paramref name="fieldSymbol"/>.</returns>
-        public static Diagnostic GetDiagnosticForFieldWithOrphanedDependentAttributes(IFieldSymbol fieldSymbol)
-        {
-            return FieldWithOrphanedDependentObservablePropertyAttributesError.CreateDiagnostic(
-                fieldSymbol,
-                fieldSymbol.ContainingType,
-                fieldSymbol.Name);
-        }
-
         /// <summary>
         /// Validates the containing type for a given field being annotated.
         /// </summary>
diff --git a/CommunityToolkit.Mvvm.SourceGenerators/ComponentModel/ObservablePropertyGenerator.cs b/CommunityToolkit.Mvvm.SourceGenerators/ComponentModel/ObservablePropertyGenerator.cs
@@ -46,20 +46,6 @@ public void Initialize(IncrementalGeneratorInitializationContext context)
             fieldSymbols
             .Where(static item => item.HasAttributeWithFullyQualifiedName("global::CommunityToolkit.Mvvm.ComponentModel.ObservablePropertyAttribute"));
 
-        // Get diagnostics for fields using [NotifyPropertyChangedFor], [NotifyCanExecuteChangedFor], [NotifyPropertyChangedRecipients] and [NotifyDataErrorInfo], but not [ObservableProperty]
-        IncrementalValuesProvider<Diagnostic> fieldSymbolsWithOrphanedDependentAttributeWithErrors =
-            fieldSymbols
-            .Where(static item =>
-                (item.HasAttributeWithFullyQualifiedName("global::CommunityToolkit.Mvvm.ComponentModel.NotifyPropertyChangedForAttribute") ||
-                 item.HasAttributeWithFullyQualifiedName("global::CommunityToolkit.Mvvm.ComponentModel.NotifyCanExecuteChangedForAttribute") ||
-                 item.HasAttributeWithFullyQualifiedName("global::CommunityToolkit.Mvvm.ComponentModel.NotifyPropertyChangedRecipientsAttribute") ||
-                 item.HasAttributeWithFullyQualifiedName("global::CommunityToolkit.Mvvm.ComponentModel.NotifyDataErrorInfoAttribute")) &&
-                 !item.HasAttributeWithFullyQualifiedName("global::CommunityToolkit.Mvvm.ComponentModel.ObservablePropertyAttribute"))
-            .Select(static (item, _) => Execute.GetDiagnosticForFieldWithOrphanedDependentAttributes(item));
-
-        // Output the diagnostics
-        context.ReportDiagnostics(fieldSymbolsWithOrphanedDependentAttributeWithErrors);
-
         // Gather info for all annotated fields
         IncrementalValuesProvider<(HierarchyInfo Hierarchy, Result<PropertyInfo?> Info)> propertyInfoWithErrors =
             fieldSymbolsWithAttribute
diff --git a/CommunityToolkit.Mvvm.SourceGenerators/Diagnostics/Analyzers/FieldWithOrphanedDependentObservablePropertyAttributesAnalyzer.cs b/CommunityToolkit.Mvvm.SourceGenerators/Diagnostics/Analyzers/FieldWithOrphanedDependentObservablePropertyAttributesAnalyzer.cs
@@ -0,0 +1,91 @@
+// 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.CSharp;
+using Microsoft.CodeAnalysis.Diagnostics;
+using static CommunityToolkit.Mvvm.SourceGenerators.Diagnostics.DiagnosticDescriptors;
+
+namespace CommunityToolkit.Mvvm.SourceGenerators;
+
+/// <summary>
+/// A diagnostic analyzer that generates an error whenever a field has an orphaned attribute that depends on <c>[ObservableProperty]</c>.
+/// </summary>
+[DiagnosticAnalyzer(LanguageNames.CSharp)]
+public sealed class FieldWithOrphanedDependentObservablePropertyAttributesAnalyzer : 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>("NotifyCanExecuteChangedForAttribute", "CommunityToolkit.Mvvm.ComponentModel.NotifyCanExecuteChangedForAttribute"),
+        new KeyValuePair<string, string>("NotifyDataErrorInfoAttribute", "CommunityToolkit.Mvvm.ComponentModel.NotifyDataErrorInfoAttribute"),
+        new KeyValuePair<string, string>("NotifyPropertyChangedForAttribute", "CommunityToolkit.Mvvm.ComponentModel.NotifyPropertyChangedForAttribute"),
+        new KeyValuePair<string, string>("NotifyPropertyChangedRecipientsAttribute", "CommunityToolkit.Mvvm.ComponentModel.NotifyPropertyChangedRecipientsAttribute")
+    });
+
+    /// <inheritdoc/>
+    public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics { get; } = ImmutableArray.Create(FieldWithOrphanedDependentObservablePropertyAttributesError);
+
+    /// <inheritdoc/>
+    public override void Initialize(AnalysisContext context)
+    {
+        context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.Analyze | GeneratedCodeAnalysisFlags.ReportDiagnostics);
+        context.EnableConcurrentExecution();
+
+        // Defer the registration so it can be skipped if C# 8.0 or more is not available.
+        // That is because in that case source generators are not supported at all anyaway.
+        context.RegisterCompilationStartAction(static context =>
+        {
+            if (!context.Compilation.HasLanguageVersionAtLeastEqualTo(LanguageVersion.CSharp8))
+            {
+                return;
+            }
+
+            context.RegisterSymbolAction(static context =>
+            {
+                ImmutableArray<AttributeData> attributes = context.Symbol.GetAttributes();
+
+                // If the symbol has no attributes, there's nothing left to do
+                if (attributes.IsEmpty)
+                {
+                    return;
+                }
+
+                foreach (AttributeData dependentAttribute in attributes)
+                {
+                    // Go over each attribute on the target symbol, anche check if any of them matches one of the trigger attributes.
+                    // The logic here is the same as the one in UnsupportedCSharpLanguageVersionAnalyzer, to minimize retrieving symbols.
+                    if (dependentAttribute.AttributeClass is { Name: string attributeName } dependentAttributeClass &&
+                        GeneratorAttributeNamesToFullyQualifiedNamesMap.TryGetValue(attributeName, out string? fullyQualifiedDependentAttributeName) &&
+                        context.Compilation.GetTypeByMetadataName(fullyQualifiedDependentAttributeName) is INamedTypeSymbol dependentAttributeSymbol &&
+                        SymbolEqualityComparer.Default.Equals(dependentAttributeClass, dependentAttributeSymbol))
+                    {
+                        // If the attribute matches, iterate over the attributes to try to find [ObservableProperty]
+                        foreach (AttributeData attribute in attributes)
+                        {
+                            if (attribute.AttributeClass is { Name: "ObservablePropertyAttribute" } attributeSymbol &&
+                                context.Compilation.GetTypeByMetadataName("CommunityToolkit.Mvvm.ComponentModel.ObservablePropertyAttribute") is INamedTypeSymbol observablePropertySymbol &&
+                                SymbolEqualityComparer.Default.Equals(attributeSymbol, observablePropertySymbol))
+                            {
+                                // If [ObservableProperty] is found, then this field is valid in that it doesn't have orphaned dependent attributes
+                                return;
+                            }
+                        }
+
+                        context.ReportDiagnostic(Diagnostic.Create(FieldWithOrphanedDependentObservablePropertyAttributesError, context.Symbol.Locations.FirstOrDefault(), context.Symbol.ContainingType, context.Symbol.Name));
+
+                        // Just like in UnsupportedCSharpLanguageVersionAnalyzer, stop if a diagnostic has been emitted for the current symbol
+                        return;
+                    }
+                }
+            }, SymbolKind.Field);
+        });
+    }
+}
diff --git a/tests/CommunityToolkit.Mvvm.SourceGenerators.UnitTests/Test_SourceGeneratorsDiagnostics.cs b/tests/CommunityToolkit.Mvvm.SourceGenerators.UnitTests/Test_SourceGeneratorsDiagnostics.cs
@@ -14,6 +14,7 @@
 using System.Threading.Tasks;
 using CommunityToolkit.Mvvm.SourceGenerators.UnitTests.Helpers;
 using System.Text.RegularExpressions;
+using Microsoft.CodeAnalysis.Diagnostics;
 
 namespace CommunityToolkit.Mvvm.SourceGenerators.UnitTests;
 
@@ -247,7 +248,7 @@ public partial class {|MVVMTK0008:SampleViewModel|}
                 }
             }";
 
-        await VerifyUnsupportedCSharpVersionAndSuccessfulGeneration(source);
+        await VerifyAnalyzerDiagnosticsAndSuccessfulGeneration<UnsupportedCSharpLanguageVersionAnalyzer>(source, LanguageVersion.CSharp7_3);
     }
 
     [TestMethod]
@@ -264,7 +265,7 @@ public partial class {|MVVMTK0008:SampleViewModel|}
                 }
             }";
 
-        await VerifyUnsupportedCSharpVersionAndSuccessfulGeneration(source);
+        await VerifyAnalyzerDiagnosticsAndSuccessfulGeneration<UnsupportedCSharpLanguageVersionAnalyzer>(source, LanguageVersion.CSharp7_3);
     }
 
     [TestMethod]
@@ -283,7 +284,7 @@ public partial class {|MVVMTK0008:SampleViewModel|}
                 }
             }";
 
-        await VerifyUnsupportedCSharpVersionAndSuccessfulGeneration(source);
+        await VerifyAnalyzerDiagnosticsAndSuccessfulGeneration<UnsupportedCSharpLanguageVersionAnalyzer>(source, LanguageVersion.CSharp7_3);
     }
 
     [TestMethod]
@@ -308,7 +309,7 @@ public partial class {|MVVMTK0008:SampleViewModel|}
                 }
             }";
 
-        await VerifyUnsupportedCSharpVersionAndSuccessfulGeneration(source);
+        await VerifyAnalyzerDiagnosticsAndSuccessfulGeneration<UnsupportedCSharpLanguageVersionAnalyzer>(source, LanguageVersion.CSharp7_3);
     }
 
     [TestMethod]
@@ -327,7 +328,7 @@ public partial class SampleViewModel : ObservableValidator
                 }
             }";
 
-        await VerifyUnsupportedCSharpVersionAndSuccessfulGeneration(source);
+        await VerifyAnalyzerDiagnosticsAndSuccessfulGeneration<UnsupportedCSharpLanguageVersionAnalyzer>(source, LanguageVersion.CSharp7_3);
     }
 
     [TestMethod]
@@ -347,7 +348,7 @@ public partial class SampleViewModel
                 }
             }";
 
-        await VerifyUnsupportedCSharpVersionAndSuccessfulGeneration(source);
+        await VerifyAnalyzerDiagnosticsAndSuccessfulGeneration<UnsupportedCSharpLanguageVersionAnalyzer>(source, LanguageVersion.CSharp7_3);
     }
 
     [TestMethod]
@@ -370,7 +371,7 @@ public void Receive(MyMessage message)
                 }
             }";
 
-        await VerifyUnsupportedCSharpVersionAndSuccessfulGeneration(source);
+        await VerifyAnalyzerDiagnosticsAndSuccessfulGeneration<UnsupportedCSharpLanguageVersionAnalyzer>(source, LanguageVersion.CSharp7_3);
     }
 
     [TestMethod]
@@ -980,7 +981,7 @@ public partial class MyViewModel : INotifyPropertyChanged
     }
 
     [TestMethod]
-    public void FieldWithOrphanedDependentObservablePropertyAttributesError_NotifyPropertyChangedFor()
+    public async Task FieldWithOrphanedDependentObservablePropertyAttributesError_NotifyPropertyChangedFor()
     {
         string source = @"
             using CommunityToolkit.Mvvm.ComponentModel;
@@ -989,16 +990,16 @@ namespace MyApp
             {
                 public partial class MyViewModel
                 {
-                    [NotifyPropertyChangedFor("")]
-                    public int number;
+                    [NotifyPropertyChangedFor("""")]
+                    public int {|MVVMTK0020:number|};
                 }
             }";
 
-        VerifyGeneratedDiagnostics<ObservablePropertyGenerator>(source, "MVVMTK0020");
+        await VerifyAnalyzerDiagnosticsAndSuccessfulGeneration<FieldWithOrphanedDependentObservablePropertyAttributesAnalyzer>(source, LanguageVersion.CSharp8);
     }
 
     [TestMethod]
-    public void FieldWithOrphanedDependentObservablePropertyAttributesError_NotifyCanExecuteChangedFor()
+    public async Task FieldWithOrphanedDependentObservablePropertyAttributesError_NotifyCanExecuteChangedFor()
     {
         string source = @"
             using CommunityToolkit.Mvvm.ComponentModel;
@@ -1007,16 +1008,16 @@ namespace MyApp
             {
                 public partial class MyViewModel
                 {
-                    [NotifyCanExecuteChangedFor("")]
-                    public int number;
+                    [NotifyCanExecuteChangedFor("""")]
+                    public int {|MVVMTK0020:number|};
                 }
             }";
 
-        VerifyGeneratedDiagnostics<ObservablePropertyGenerator>(source, "MVVMTK0020");
+        await VerifyAnalyzerDiagnosticsAndSuccessfulGeneration<FieldWithOrphanedDependentObservablePropertyAttributesAnalyzer>(source, LanguageVersion.CSharp8);
     }
 
     [TestMethod]
-    public void FieldWithOrphanedDependentObservablePropertyAttributesError_NotifyPropertyChangedRecipients()
+    public async Task FieldWithOrphanedDependentObservablePropertyAttributesError_NotifyPropertyChangedRecipients()
     {
         string source = @"
             using CommunityToolkit.Mvvm.ComponentModel;
@@ -1026,15 +1027,15 @@ namespace MyApp
                 public partial class MyViewModel
                 {
                     [NotifyPropertyChangedRecipients]
-                    public int number;
+                    public int {|MVVMTK0020:number|};
                 }
             }";
 
-        VerifyGeneratedDiagnostics<ObservablePropertyGenerator>(source, "MVVMTK0020");
+        await VerifyAnalyzerDiagnosticsAndSuccessfulGeneration<FieldWithOrphanedDependentObservablePropertyAttributesAnalyzer>(source, LanguageVersion.CSharp8);
     }
 
     [TestMethod]
-    public void FieldWithOrphanedDependentObservablePropertyAttributesError_MultipleUsesStillGenerateOnlyASingleDiagnostic()
+    public async Task FieldWithOrphanedDependentObservablePropertyAttributesError_MultipleUsesStillGenerateOnlyASingleDiagnostic()
     {
         string source = @"
             using CommunityToolkit.Mvvm.ComponentModel;
@@ -1043,17 +1044,17 @@ namespace MyApp
             {
                 public partial class MyViewModel
                 {
-                    [NotifyPropertyChangedFor("")]
-                    [NotifyPropertyChangedFor("")]
-                    [NotifyPropertyChangedFor("")]
-                    [NotifyCanExecuteChangedFor("")]
-                    [NotifyCanExecuteChangedFor("")]
+                    [NotifyPropertyChangedFor("""")]
+                    [NotifyPropertyChangedFor("""")]
+                    [NotifyPropertyChangedFor("""")]
+                    [NotifyCanExecuteChangedFor("""")]
+                    [NotifyCanExecuteChangedFor("""")]
                     [NotifyPropertyChangedRecipients]
-                    public int number;
+                    public int {|MVVMTK0020:number|};
                 }
             }";
 
-        VerifyGeneratedDiagnostics<ObservablePropertyGenerator>(source, "MVVMTK0020");
+        await VerifyAnalyzerDiagnosticsAndSuccessfulGeneration<FieldWithOrphanedDependentObservablePropertyAttributesAnalyzer>(source, LanguageVersion.CSharp8);
     }
 
     [TestMethod]
@@ -1428,12 +1429,15 @@ private void GreetUser(User user)
     }
 
     /// <summary>
-    /// Verifies the diagnostic error for unsupported C# version, and that all available source generators can run successfully with the input source (including subsequent compilation).
+    /// Verifies the diagnostic errors for a given analyzer, and that all available source generators can run successfully with the input source (including subsequent compilation).
     /// </summary>
+    /// <typeparam name="TAnalyzer">The type of the analyzer to test.</typeparam>
     /// <param name="markdownSource">The input source to process with diagnostic annotations.</param>
-    private static async Task VerifyUnsupportedCSharpVersionAndSuccessfulGeneration(string markdownSource)
+    /// <param name="languageVersion">The language version to use to parse code and run tests.</param>
+    private static async Task VerifyAnalyzerDiagnosticsAndSuccessfulGeneration<TAnalyzer>(string markdownSource, LanguageVersion languageVersion)
+        where TAnalyzer : DiagnosticAnalyzer, new()
     {
-        await CSharpAnalyzerWithLanguageVersionTest<UnsupportedCSharpLanguageVersionAnalyzer>.VerifyAnalyzerAsync(markdownSource, LanguageVersion.CSharp7_3);
+        await CSharpAnalyzerWithLanguageVersionTest<TAnalyzer>.VerifyAnalyzerAsync(markdownSource, languageVersion);
 
         IIncrementalGenerator[] generators =
         {
@@ -1450,7 +1454,7 @@ private static async Task VerifyUnsupportedCSharpVersionAndSuccessfulGeneration(
         // Transform diagnostic annotations back to normal C# (eg. "{|MVVMTK0008:Foo()|}" ---> "Foo()")
         string source = Regex.Replace(markdownSource, @"{\|((?:,?\w+)+):(.+)\|}", m => m.Groups[2].Value);
 
-        VerifyGeneratedDiagnostics(CSharpSyntaxTree.ParseText(source, CSharpParseOptions.Default.WithLanguageVersion(LanguageVersion.CSharp7_3)), generators, Array.Empty<string>());
+        VerifyGeneratedDiagnostics(CSharpSyntaxTree.ParseText(source, CSharpParseOptions.Default.WithLanguageVersion(languageVersion)), generators, Array.Empty<string>());
     }
 
     /// <summary>

Original file line number	Diff line number	Diff line change
`@@ -14,6 +14,7 @@`
`14`	`14`	`using System.Threading.Tasks;`
`15`	`15`	`using CommunityToolkit.Mvvm.SourceGenerators.UnitTests.Helpers;`
`16`	`16`	`using System.Text.RegularExpressions;`
	`17`	`+using Microsoft.CodeAnalysis.Diagnostics;`
`17`	`18`
`18`	`19`	`namespace CommunityToolkit.Mvvm.SourceGenerators.UnitTests;`
`19`	`20`
`@@ -247,7 +248,7 @@ public partial class {\|MVVMTK0008:SampleViewModel\|}`
`247`	`248`	`}`
`248`	`249`	`}";`
`249`	`250`
`250`		`- await VerifyUnsupportedCSharpVersionAndSuccessfulGeneration(source);`
	`251`	`+ await VerifyAnalyzerDiagnosticsAndSuccessfulGeneration<UnsupportedCSharpLanguageVersionAnalyzer>(source, LanguageVersion.CSharp7_3);`
`251`	`252`	`}`
`252`	`253`
`253`	`254`	`[TestMethod]`
`@@ -264,7 +265,7 @@ public partial class {\|MVVMTK0008:SampleViewModel\|}`
`264`	`265`	`}`
`265`	`266`	`}";`
`266`	`267`
`267`		`- await VerifyUnsupportedCSharpVersionAndSuccessfulGeneration(source);`
	`268`	`+ await VerifyAnalyzerDiagnosticsAndSuccessfulGeneration<UnsupportedCSharpLanguageVersionAnalyzer>(source, LanguageVersion.CSharp7_3);`
`268`	`269`	`}`
`269`	`270`
`270`	`271`	`[TestMethod]`
`@@ -283,7 +284,7 @@ public partial class {\|MVVMTK0008:SampleViewModel\|}`
`283`	`284`	`}`
`284`	`285`	`}";`
`285`	`286`
`286`		`- await VerifyUnsupportedCSharpVersionAndSuccessfulGeneration(source);`
	`287`	`+ await VerifyAnalyzerDiagnosticsAndSuccessfulGeneration<UnsupportedCSharpLanguageVersionAnalyzer>(source, LanguageVersion.CSharp7_3);`
`287`	`288`	`}`
`288`	`289`
`289`	`290`	`[TestMethod]`
`@@ -308,7 +309,7 @@ public partial class {\|MVVMTK0008:SampleViewModel\|}`
`308`	`309`	`}`
`309`	`310`	`}";`
`310`	`311`
`311`		`- await VerifyUnsupportedCSharpVersionAndSuccessfulGeneration(source);`
	`312`	`+ await VerifyAnalyzerDiagnosticsAndSuccessfulGeneration<UnsupportedCSharpLanguageVersionAnalyzer>(source, LanguageVersion.CSharp7_3);`
`312`	`313`	`}`
`313`	`314`
`314`	`315`	`[TestMethod]`
`@@ -327,7 +328,7 @@ public partial class SampleViewModel : ObservableValidator`
`327`	`328`	`}`
`328`	`329`	`}";`
`329`	`330`
`330`		`- await VerifyUnsupportedCSharpVersionAndSuccessfulGeneration(source);`
	`331`	`+ await VerifyAnalyzerDiagnosticsAndSuccessfulGeneration<UnsupportedCSharpLanguageVersionAnalyzer>(source, LanguageVersion.CSharp7_3);`
`331`	`332`	`}`
`332`	`333`
`333`	`334`	`[TestMethod]`
`@@ -347,7 +348,7 @@ public partial class SampleViewModel`
`347`	`348`	`}`
`348`	`349`	`}";`
`349`	`350`
`350`		`- await VerifyUnsupportedCSharpVersionAndSuccessfulGeneration(source);`
	`351`	`+ await VerifyAnalyzerDiagnosticsAndSuccessfulGeneration<UnsupportedCSharpLanguageVersionAnalyzer>(source, LanguageVersion.CSharp7_3);`
`351`	`352`	`}`
`352`	`353`
`353`	`354`	`[TestMethod]`
`@@ -370,7 +371,7 @@ public void Receive(MyMessage message)`
`370`	`371`	`}`
`371`	`372`	`}";`
`372`	`373`
`373`		`- await VerifyUnsupportedCSharpVersionAndSuccessfulGeneration(source);`
	`374`	`+ await VerifyAnalyzerDiagnosticsAndSuccessfulGeneration<UnsupportedCSharpLanguageVersionAnalyzer>(source, LanguageVersion.CSharp7_3);`
`374`	`375`	`}`
`375`	`376`
`376`	`377`	`[TestMethod]`
`@@ -980,7 +981,7 @@ public partial class MyViewModel : INotifyPropertyChanged`
`980`	`981`	`}`
`981`	`982`
`982`	`983`	`[TestMethod]`
`983`		`- public void FieldWithOrphanedDependentObservablePropertyAttributesError_NotifyPropertyChangedFor()`
	`984`	`+ public async Task FieldWithOrphanedDependentObservablePropertyAttributesError_NotifyPropertyChangedFor()`
`984`	`985`	`{`
`985`	`986`	`string source = @"`
`986`	`987`	`using CommunityToolkit.Mvvm.ComponentModel;`
`@@ -989,16 +990,16 @@ namespace MyApp`
`989`	`990`	`{`
`990`	`991`	`public partial class MyViewModel`
`991`	`992`	`{`
`992`		`- [NotifyPropertyChangedFor("")]`
`993`		`- public int number;`
	`993`	`+ [NotifyPropertyChangedFor("""")]`
	`994`	`+ public int {\|MVVMTK0020:number\|};`
`994`	`995`	`}`
`995`	`996`	`}";`
`996`	`997`
`997`		`- VerifyGeneratedDiagnostics<ObservablePropertyGenerator>(source, "MVVMTK0020");`
	`998`	`+ await VerifyAnalyzerDiagnosticsAndSuccessfulGeneration<FieldWithOrphanedDependentObservablePropertyAttributesAnalyzer>(source, LanguageVersion.CSharp8);`
`998`	`999`	`}`
`999`	`1000`
`1000`	`1001`	`[TestMethod]`
`1001`		`- public void FieldWithOrphanedDependentObservablePropertyAttributesError_NotifyCanExecuteChangedFor()`
	`1002`	`+ public async Task FieldWithOrphanedDependentObservablePropertyAttributesError_NotifyCanExecuteChangedFor()`
`1002`	`1003`	`{`
`1003`	`1004`	`string source = @"`
`1004`	`1005`	`using CommunityToolkit.Mvvm.ComponentModel;`
`@@ -1007,16 +1008,16 @@ namespace MyApp`
`1007`	`1008`	`{`
`1008`	`1009`	`public partial class MyViewModel`
`1009`	`1010`	`{`
`1010`		`- [NotifyCanExecuteChangedFor("")]`
`1011`		`- public int number;`
	`1011`	`+ [NotifyCanExecuteChangedFor("""")]`
	`1012`	`+ public int {\|MVVMTK0020:number\|};`
`1012`	`1013`	`}`
`1013`	`1014`	`}";`
`1014`	`1015`
`1015`		`- VerifyGeneratedDiagnostics<ObservablePropertyGenerator>(source, "MVVMTK0020");`
	`1016`	`+ await VerifyAnalyzerDiagnosticsAndSuccessfulGeneration<FieldWithOrphanedDependentObservablePropertyAttributesAnalyzer>(source, LanguageVersion.CSharp8);`
`1016`	`1017`	`}`
`1017`	`1018`
`1018`	`1019`	`[TestMethod]`
`1019`		`- public void FieldWithOrphanedDependentObservablePropertyAttributesError_NotifyPropertyChangedRecipients()`
	`1020`	`+ public async Task FieldWithOrphanedDependentObservablePropertyAttributesError_NotifyPropertyChangedRecipients()`
`1020`	`1021`	`{`
`1021`	`1022`	`string source = @"`
`1022`	`1023`	`using CommunityToolkit.Mvvm.ComponentModel;`
`@@ -1026,15 +1027,15 @@ namespace MyApp`
`1026`	`1027`	`public partial class MyViewModel`
`1027`	`1028`	`{`
`1028`	`1029`	`[NotifyPropertyChangedRecipients]`
`1029`		`- public int number;`
	`1030`	`+ public int {\|MVVMTK0020:number\|};`
`1030`	`1031`	`}`
`1031`	`1032`	`}";`
`1032`	`1033`
`1033`		`- VerifyGeneratedDiagnostics<ObservablePropertyGenerator>(source, "MVVMTK0020");`
	`1034`	`+ await VerifyAnalyzerDiagnosticsAndSuccessfulGeneration<FieldWithOrphanedDependentObservablePropertyAttributesAnalyzer>(source, LanguageVersion.CSharp8);`
`1034`	`1035`	`}`
`1035`	`1036`
`1036`	`1037`	`[TestMethod]`
`1037`		`- public void FieldWithOrphanedDependentObservablePropertyAttributesError_MultipleUsesStillGenerateOnlyASingleDiagnostic()`
	`1038`	`+ public async Task FieldWithOrphanedDependentObservablePropertyAttributesError_MultipleUsesStillGenerateOnlyASingleDiagnostic()`
`1038`	`1039`	`{`
`1039`	`1040`	`string source = @"`
`1040`	`1041`	`using CommunityToolkit.Mvvm.ComponentModel;`
`@@ -1043,17 +1044,17 @@ namespace MyApp`
`1043`	`1044`	`{`
`1044`	`1045`	`public partial class MyViewModel`
`1045`	`1046`	`{`
`1046`		`- [NotifyPropertyChangedFor("")]`
`1047`		`- [NotifyPropertyChangedFor("")]`
`1048`		`- [NotifyPropertyChangedFor("")]`
`1049`		`- [NotifyCanExecuteChangedFor("")]`
`1050`		`- [NotifyCanExecuteChangedFor("")]`
	`1047`	`+ [NotifyPropertyChangedFor("""")]`
	`1048`	`+ [NotifyPropertyChangedFor("""")]`
	`1049`	`+ [NotifyPropertyChangedFor("""")]`
	`1050`	`+ [NotifyCanExecuteChangedFor("""")]`
	`1051`	`+ [NotifyCanExecuteChangedFor("""")]`
`1051`	`1052`	`[NotifyPropertyChangedRecipients]`
`1052`		`- public int number;`
	`1053`	`+ public int {\|MVVMTK0020:number\|};`
`1053`	`1054`	`}`
`1054`	`1055`	`}";`
`1055`	`1056`
`1056`		`- VerifyGeneratedDiagnostics<ObservablePropertyGenerator>(source, "MVVMTK0020");`
	`1057`	`+ await VerifyAnalyzerDiagnosticsAndSuccessfulGeneration<FieldWithOrphanedDependentObservablePropertyAttributesAnalyzer>(source, LanguageVersion.CSharp8);`
`1057`	`1058`	`}`
`1058`	`1059`
`1059`	`1060`	`[TestMethod]`
`@@ -1428,12 +1429,15 @@ private void GreetUser(User user)`
`1428`	`1429`	`}`
`1429`	`1430`
`1430`	`1431`	`/// <summary>`
`1431`		`- /// Verifies the diagnostic error for unsupported C# version, and that all available source generators can run successfully with the input source (including subsequent compilation).`
	`1432`	`+ /// Verifies the diagnostic errors for a given analyzer, and that all available source generators can run successfully with the input source (including subsequent compilation).`
`1432`	`1433`	`/// </summary>`
	`1434`	`+ /// <typeparam name="TAnalyzer">The type of the analyzer to test.</typeparam>`
`1433`	`1435`	`/// <param name="markdownSource">The input source to process with diagnostic annotations.</param>`
`1434`		`- private static async Task VerifyUnsupportedCSharpVersionAndSuccessfulGeneration(string markdownSource)`
	`1436`	`+ /// <param name="languageVersion">The language version to use to parse code and run tests.</param>`
	`1437`	`+ private static async Task VerifyAnalyzerDiagnosticsAndSuccessfulGeneration<TAnalyzer>(string markdownSource, LanguageVersion languageVersion)`
	`1438`	`+ where TAnalyzer : DiagnosticAnalyzer, new()`
`1435`	`1439`	`{`
`1436`		`- await CSharpAnalyzerWithLanguageVersionTest<UnsupportedCSharpLanguageVersionAnalyzer>.VerifyAnalyzerAsync(markdownSource, LanguageVersion.CSharp7_3);`
	`1440`	`+ await CSharpAnalyzerWithLanguageVersionTest<TAnalyzer>.VerifyAnalyzerAsync(markdownSource, languageVersion);`
`1437`	`1441`
`1438`	`1442`	`IIncrementalGenerator[] generators =`
`1439`	`1443`	`{`
`@@ -1450,7 +1454,7 @@ private static async Task VerifyUnsupportedCSharpVersionAndSuccessfulGeneration(`
`1450`	`1454`	`// Transform diagnostic annotations back to normal C# (eg. "{\|MVVMTK0008:Foo()\|}" ---> "Foo()")`
`1451`	`1455`	`string source = Regex.Replace(markdownSource, @"{\\|((?:,?\w+)+):(.+)\\|}", m => m.Groups[2].Value);`
`1452`	`1456`
`1453`		`- VerifyGeneratedDiagnostics(CSharpSyntaxTree.ParseText(source, CSharpParseOptions.Default.WithLanguageVersion(LanguageVersion.CSharp7_3)), generators, Array.Empty<string>());`
	`1457`	`+ VerifyGeneratedDiagnostics(CSharpSyntaxTree.ParseText(source, CSharpParseOptions.Default.WithLanguageVersion(languageVersion)), generators, Array.Empty<string>());`
`1454`	`1458`	`}`
`1455`	`1459`
`1456`	`1460`	`/// <summary>`