Update source generator tests to actually generate the compiled output, update tests to use the minimum supported C# language version (8.0), and also validate that unsupported version cases actually succeed with the supported version

Author: zhuman

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

@@ -11,6 +11,7 @@
 using Microsoft.CodeAnalysis.CSharp;
 using CommunityToolkit.Mvvm.ComponentModel;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
+using System.Reflection.Emit;
 
 namespace CommunityToolkit.Mvvm.SourceGenerators.UnitTests;
 
@@ -247,6 +248,9 @@ public partial class SampleViewModel
         VerifyGeneratedDiagnostics<INotifyPropertyChangedGenerator>(
             CSharpSyntaxTree.ParseText(source, CSharpParseOptions.Default.WithLanguageVersion(LanguageVersion.CSharp7_3)),
             "MVVMTK0008");
+
+        // Ensure that it succeeds with the minimum supported language version
+        VerifySuccessfulGeneration(source);
     }
 
     [TestMethod]
@@ -266,6 +270,9 @@ public partial class SampleViewModel
         VerifyGeneratedDiagnostics<ObservableObjectGenerator>(
             CSharpSyntaxTree.ParseText(source, CSharpParseOptions.Default.WithLanguageVersion(LanguageVersion.CSharp7_3)),
             "MVVMTK0008");
+
+        // Ensure that it succeeds with the minimum supported language version
+        VerifySuccessfulGeneration(source);
     }
 
     [TestMethod]
@@ -287,12 +294,16 @@ public partial class SampleViewModel
         VerifyGeneratedDiagnostics<ObservablePropertyGenerator>(
             CSharpSyntaxTree.ParseText(source, CSharpParseOptions.Default.WithLanguageVersion(LanguageVersion.CSharp7_3)),
             "MVVMTK0008");
+
+        // Ensure that it succeeds with the minimum supported language version
+        VerifySuccessfulGeneration(source);
     }
 
     [TestMethod]
     public void UnsupportedCSharpLanguageVersion_FromObservableValidatorValidateAllPropertiesGenerator()
     {
         string source = @"
+            using System.ComponentModel.DataAnnotations;
             using CommunityToolkit.Mvvm.ComponentModel;
 
             namespace MyApp
@@ -304,9 +315,12 @@ public partial class SampleViewModel : ObservableValidator
                 }
             }";
 
-        // This is explicitly allowed in C# < 8.0, as it doesn't use any new features
         VerifyGeneratedDiagnostics<ObservableValidatorValidateAllPropertiesGenerator>(
-            CSharpSyntaxTree.ParseText(source, CSharpParseOptions.Default.WithLanguageVersion(LanguageVersion.CSharp7_3)));
+            CSharpSyntaxTree.ParseText(source, CSharpParseOptions.Default.WithLanguageVersion(LanguageVersion.CSharp7_3)),
+            "MVVMTK0008");
+
+        // Ensure that it succeeds with the minimum supported language version
+        VerifySuccessfulGeneration(source);
     }
 
     [TestMethod]
@@ -329,6 +343,9 @@ private void GreetUser(object value)
         VerifyGeneratedDiagnostics<RelayCommandGenerator>(
             CSharpSyntaxTree.ParseText(source, CSharpParseOptions.Default.WithLanguageVersion(LanguageVersion.CSharp7_3)),
             "MVVMTK0008");
+
+        // Ensure that it succeeds with the minimum supported language version
+        VerifySuccessfulGeneration(source);
     }
 
     [TestMethod]
@@ -351,9 +368,12 @@ public void Receive(MyMessage message)
                 }
             }";
 
-        // This is explicitly allowed in C# < 8.0, as it doesn't use any new features
         VerifyGeneratedDiagnostics<IMessengerRegisterAllGenerator>(
-            CSharpSyntaxTree.ParseText(source, CSharpParseOptions.Default.WithLanguageVersion(LanguageVersion.CSharp7_3)));
+            CSharpSyntaxTree.ParseText(source, CSharpParseOptions.Default.WithLanguageVersion(LanguageVersion.CSharp7_3)),
+            "MVVMTK0008");
+
+        // Ensure that it succeeds with the minimum supported language version
+        VerifySuccessfulGeneration(source);
     }
 
     [TestMethod]
@@ -1410,6 +1430,29 @@ private void GreetUser(User user)
         VerifyGeneratedDiagnostics<RelayCommandGenerator>(source, "MVVMTK0031");
     }
 
+    [TestMethod]
+    public void ValidObservablePropertyGeneratorScenarios()
+    {
+        string source = @"
+            using CommunityToolkit.Mvvm.ComponentModel;
+
+            namespace MyApp
+            {
+                [ObservableObject]
+                public partial class SampleViewModel
+                {
+                    [ObservableProperty]
+                    string name;
+
+                    [ObservableProperty]
+                    [NotifyPropertyChangedFor(nameof(Name))]
+                    int number;
+                }
+            }";
+
+        VerifySuccessfulGeneration(source);
+    }
+
     /// <summary>
     /// Verifies the output of a source generator.
     /// </summary>
@@ -1419,17 +1462,50 @@ private void GreetUser(User user)
     private static void VerifyGeneratedDiagnostics<TGenerator>(string source, params string[] diagnosticsIds)
         where TGenerator : class, IIncrementalGenerator, new()
     {
-        VerifyGeneratedDiagnostics<TGenerator>(CSharpSyntaxTree.ParseText(source), diagnosticsIds);
+        IIncrementalGenerator generator = new TGenerator();
+        VerifyGeneratedDiagnostics(CSharpSyntaxTree.ParseText(source, CSharpParseOptions.Default.WithLanguageVersion(LanguageVersion.CSharp8)), new[] { generator }, diagnosticsIds);
+    }
+
+    /// <summary>
+    /// Verifies the output of all source generators for input source (including subsequent compilation).
+    /// </summary>
+    /// <param name="source"></param>
+    private static void VerifySuccessfulGeneration(string source)
+    {
+        IIncrementalGenerator[] generators =
+        {
+            new IMessengerRegisterAllGenerator(),
+            new NullabilityAttributesGenerator(),
+            new ObservableObjectGenerator(),
+            new INotifyPropertyChangedGenerator(),
+            new ObservablePropertyGenerator(),
+            new ObservableRecipientGenerator(),
+            new ObservableValidatorValidateAllPropertiesGenerator(),
+            new RelayCommandGenerator()
+        };
+        VerifyGeneratedDiagnostics(CSharpSyntaxTree.ParseText(source, CSharpParseOptions.Default.WithLanguageVersion(LanguageVersion.CSharp8)), generators, new string[] { });
     }
 
     /// <summary>
     /// Verifies the output of a source generator.
     /// </summary>
     /// <typeparam name="TGenerator">The generator type to use.</typeparam>
-    /// <param name="syntaxTree">The input source tree to process.</param>
+    /// <param name="syntaxTree">The input source to process.</param>
     /// <param name="diagnosticsIds">The diagnostic ids to expect for the input source code.</param>
     private static void VerifyGeneratedDiagnostics<TGenerator>(SyntaxTree syntaxTree, params string[] diagnosticsIds)
         where TGenerator : class, IIncrementalGenerator, new()
+    {
+        IIncrementalGenerator generator = new TGenerator();
+        VerifyGeneratedDiagnostics(syntaxTree, new[] { generator }, diagnosticsIds);
+    }
+
+    /// <summary>
+    /// Verifies the output of a source generator.
+    /// </summary>
+    /// <typeparam name="TGenerator">The generator type to use.</typeparam>
+    /// <param name="syntaxTree">The input source tree to process.</param>
+    /// <param name="diagnosticsIds">The diagnostic ids to expect for the input source code.</param>
+    private static void VerifyGeneratedDiagnostics(SyntaxTree syntaxTree, IIncrementalGenerator[] generators, string[] generatorDiagnosticsIds)
     {
         Type observableObjectType = typeof(ObservableObject);
         Type validationAttributeType = typeof(ValidationAttribute);
@@ -1446,15 +1522,22 @@ from assembly in AppDomain.CurrentDomain.GetAssemblies()
             references,
             new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary));
 
-        IIncrementalGenerator generator = new TGenerator();
-
-        GeneratorDriver driver = CSharpGeneratorDriver.Create(generator).WithUpdatedParseOptions((CSharpParseOptions)syntaxTree.Options);
+        GeneratorDriver driver = CSharpGeneratorDriver.Create(generators).WithUpdatedParseOptions((CSharpParseOptions)syntaxTree.Options);
 
         _ = driver.RunGeneratorsAndUpdateCompilation(compilation, out Compilation outputCompilation, out ImmutableArray<Diagnostic> diagnostics);
 
         HashSet<string> resultingIds = diagnostics.Select(diagnostic => diagnostic.Id).ToHashSet();
 
-        CollectionAssert.AreEquivalent(diagnosticsIds, resultingIds.ToArray());
+        CollectionAssert.AreEquivalent(generatorDiagnosticsIds, resultingIds.ToArray(), $"resultingIds: {string.Join(", ", resultingIds)}");
+
+        // If the compilation was supposed to succeed, ensure that no further errors were generated
+        if (resultingIds.Count == 0)
+        {
+            // Compute diagnostics for the final compiled output (just include errors)
+            List<Diagnostic> outputCompilationDiagnostics = outputCompilation.GetDiagnostics().Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error).ToList();
+
+            Assert.IsTrue(outputCompilationDiagnostics.Count == 0, $"resultingIds:{Environment.NewLine} {string.Join(Environment.NewLine, outputCompilationDiagnostics)}");
+        }
 
         GC.KeepAlive(observableObjectType);
         GC.KeepAlive(validationAttributeType);