Add FilterWithLanguageVersion extension to gate on language version

Sergio0694 · Sergio0694 · commit 9cc7d41c1ee4 · 2021-12-29T18:31:11.000+01:00
diff --git a/CommunityToolkit.Mvvm.SourceGenerators/ComponentModel/ObservablePropertyGenerator.cs b/CommunityToolkit.Mvvm.SourceGenerators/ComponentModel/ObservablePropertyGenerator.cs
@@ -27,32 +27,22 @@ public sealed partial class ObservablePropertyGenerator : IIncrementalGenerator
     /// <inheritdoc/>
     public void Initialize(IncrementalGeneratorInitializationContext context)
     {
-        // Validate the language version. Note that we're emitting this diagnostic in each generator (excluding the one
-        // only emitting the nullability annotation attributes if missing) so that the diagnostic is emitted only when
-        // users are using one of these generators, and not by default as soon as they add a reference to the MVVM Toolkit.
-        // This ensures that users not using any of the source generators won't be broken when upgrading to this new version.
-        IncrementalValueProvider<bool> isGeneratorSupported =
-            context.ParseOptionsProvider
-            .Select(static (item, _) => item is CSharpParseOptions { LanguageVersion: >= LanguageVersion.CSharp8 });
-
-        // Emit the diagnostic, if needed
-        context.ReportDiagnosticsIsNotSupported(isGeneratorSupported, Diagnostic.Create(UnsupportedCSharpLanguageVersionError, null));
-
         // Get all field declarations with at least one attribute
         IncrementalValuesProvider<IFieldSymbol> fieldSymbols =
             context.SyntaxProvider
             .CreateSyntaxProvider(
                 static (node, _) => node is FieldDeclarationSyntax { Parent: ClassDeclarationSyntax or RecordDeclarationSyntax, AttributeLists.Count: > 0 },
                 static (context, _) => ((FieldDeclarationSyntax)context.Node).Declaration.Variables.Select(v => (IFieldSymbol)context.SemanticModel.GetDeclaredSymbol(v)!))
-            .Combine(isGeneratorSupported)
-            .Where(static item => item.Right)
-            .SelectMany(static (item, _) => item.Left);
+            .SelectMany(static (item, _) => item);
 
         // Filter the fields using [ObservableProperty]
         IncrementalValuesProvider<IFieldSymbol> fieldSymbolsWithAttribute =
             fieldSymbols
             .Where(static item => item.GetAttributes().Any(a => a.AttributeClass?.HasFullyQualifiedName("global::CommunityToolkit.Mvvm.ComponentModel.ObservablePropertyAttribute") == true));
 
+        // Filter by language version
+        context.FilterWithLanguageVersion(ref fieldSymbolsWithAttribute, LanguageVersion.CSharp8, UnsupportedCSharpLanguageVersionError);
+
         // Gather info for all annotated fields
         IncrementalValuesProvider<(HierarchyInfo Hierarchy, Result<PropertyInfo> Info)> propertyInfoWithErrors =
             fieldSymbolsWithAttribute
diff --git a/CommunityToolkit.Mvvm.SourceGenerators/ComponentModel/ObservableValidatorValidateAllPropertiesGenerator.cs b/CommunityToolkit.Mvvm.SourceGenerators/ComponentModel/ObservableValidatorValidateAllPropertiesGenerator.cs
@@ -21,21 +21,12 @@ public sealed partial class ObservableValidatorValidateAllPropertiesGenerator :
     /// <inheritdoc/>
     public void Initialize(IncrementalGeneratorInitializationContext context)
     {
-        // Validate the language version (this needs at least C# 8.0 due to static local functions being used).
-        // If a lower C# version is set, just skip the execution silently. The fallback path will be used just fine.
-        IncrementalValueProvider<bool> isGeneratorSupported =
-            context.ParseOptionsProvider
-            .Select(static (item, _) => item is CSharpParseOptions { LanguageVersion: >= LanguageVersion.CSharp8 });
-
         // Get all class declarations
         IncrementalValuesProvider<INamedTypeSymbol> typeSymbols =
             context.SyntaxProvider
             .CreateSyntaxProvider(
                 static (node, _) => node is ClassDeclarationSyntax,
-                static (context, _) => (INamedTypeSymbol)context.SemanticModel.GetDeclaredSymbol(context.Node)!)
-            .Combine(isGeneratorSupported)
-            .Where(static item => item.Right)
-            .Select(static (item, _) => item.Left);
+                static (context, _) => (INamedTypeSymbol)context.SemanticModel.GetDeclaredSymbol(context.Node)!);
 
         // Get the types that inherit from ObservableValidator and gather their info
         IncrementalValuesProvider<ValidationInfo> validationInfo =
diff --git a/CommunityToolkit.Mvvm.SourceGenerators/ComponentModel/TransitiveMembersGenerator.cs b/CommunityToolkit.Mvvm.SourceGenerators/ComponentModel/TransitiveMembersGenerator.cs
@@ -4,9 +4,7 @@
 
 using System.Collections.Generic;
 using System.Collections.Immutable;
-using System.IO;
 using System.Linq;
-using System.Reflection;
 using System.Text;
 using CommunityToolkit.Mvvm.SourceGenerators.Diagnostics;
 using CommunityToolkit.Mvvm.SourceGenerators.Extensions;
@@ -15,6 +13,7 @@
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Text;
+using static CommunityToolkit.Mvvm.SourceGenerators.Diagnostics.DiagnosticDescriptors;
 
 namespace CommunityToolkit.Mvvm.SourceGenerators;
 
@@ -73,20 +72,12 @@ private protected TransitiveMembersGenerator(string attributeType, IEqualityComp
     /// <inheritdoc/>
     public void Initialize(IncrementalGeneratorInitializationContext context)
     {
-        // Validate the language version
-        IncrementalValueProvider<bool> isGeneratorSupported =
-            context.ParseOptionsProvider
-            .Select(static (item, _) => item is CSharpParseOptions { LanguageVersion: >= LanguageVersion.CSharp8 });
-
         // Get all class declarations
         IncrementalValuesProvider<INamedTypeSymbol> typeSymbols =
             context.SyntaxProvider
             .CreateSyntaxProvider(
                 static (node, _) => node is ClassDeclarationSyntax { AttributeLists.Count: > 0 },
-                static (context, _) => (INamedTypeSymbol)context.SemanticModel.GetDeclaredSymbol(context.Node)!)
-            .Combine(isGeneratorSupported)
-            .Where(static item => item.Right)
-            .Select(static (item, _) => item.Left);
+                static (context, _) => (INamedTypeSymbol)context.SemanticModel.GetDeclaredSymbol(context.Node)!);
 
         // Filter the types with the target attribute
         IncrementalValuesProvider<(INamedTypeSymbol Symbol, TInfo Info)> typeSymbolsWithInfo =
@@ -97,6 +88,9 @@ public void Initialize(IncrementalGeneratorInitializationContext context)
             .Where(static item => item.Attribute is not null)!
             .Select((item, _) => (item.Symbol, GetInfo(item.Symbol, item.Attribute!)));
 
+        // Filter by language version
+        context.FilterWithLanguageVersion(ref typeSymbolsWithInfo, LanguageVersion.CSharp8, UnsupportedCSharpLanguageVersionError);
+
         // Gather all generation info, and any diagnostics
         IncrementalValuesProvider<Result<(HierarchyInfo Hierarchy, bool IsSealed, TInfo Info)>> generationInfoWithErrors =
             typeSymbolsWithInfo.Select((item, _) =>
diff --git a/CommunityToolkit.Mvvm.SourceGenerators/Diagnostics/DiagnosticDescriptors.cs b/CommunityToolkit.Mvvm.SourceGenerators/Diagnostics/DiagnosticDescriptors.cs
@@ -131,11 +131,11 @@ internal static class DiagnosticDescriptors
     public static readonly DiagnosticDescriptor UnsupportedCSharpLanguageVersionError = new(
         id: "MVVMTK0008",
         title: "Unsupported C# language version",
-        messageFormat: "The source generator features from the MVVM Toolkit require consuming projects to set the C# language version to at least C# 9.0",
+        messageFormat: "The source generator features from the MVVM Toolkit require consuming projects to set the C# language version to at least C# 8.0",
         category: typeof(CSharpParseOptions).FullName,
         defaultSeverity: DiagnosticSeverity.Error,
         isEnabledByDefault: true,
-        description: "The source generator features from the MVVM Toolkit require consuming projects to set the C# language version to at least C# 9.0. Make sure to add <LangVersion>9.0</LangVersion> (or above) to your .csproj file.",
+        description: "The source generator features from the MVVM Toolkit require consuming projects to set the C# language version to at least C# 8.0. Make sure to add <LangVersion>8.0</LangVersion> (or above) to your .csproj file.",
         helpLinkUri: "https://aka.ms/mvvmtoolkit");
 
     /// <summary>
diff --git a/CommunityToolkit.Mvvm.SourceGenerators/Extensions/IncrementalGeneratorInitializationContextExtensions.cs b/CommunityToolkit.Mvvm.SourceGenerators/Extensions/IncrementalGeneratorInitializationContextExtensions.cs
@@ -0,0 +1,65 @@
+// 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 Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+
+namespace CommunityToolkit.Mvvm.SourceGenerators.Extensions;
+
+/// <summary>
+/// Extension methods for <see cref="IncrementalGeneratorInitializationContext"/>.
+/// </summary>
+internal static partial class IncrementalGeneratorInitializationContextExtensions
+{
+    /// <summary>
+    /// Implements a gate for a language version over items in an input <see cref="IncrementalValuesProvider{TValues}"/> source.
+    /// </summary>
+    /// <typeparam name="T">The type of items in the input <see cref="IncrementalValuesProvider{TValues}"/> source.</typeparam>
+    /// <param name="context">The input <see cref="IncrementalGeneratorInitializationContext"/> value being used.</param>
+    /// <param name="source">The source <see cref="IncrementalValuesProvider{TValues}"/> instance.</param>
+    /// <param name="languageVersion">The minimum language version to gate for.</param>
+    /// <param name="diagnosticDescriptor">The <see cref="DiagnosticDescriptor"/> to emit if the gate detects invalid usage.</param>
+    /// <remarks>
+    /// Items in <paramref name="source"/> will be filtered out if the gate fails. If it passes, items will remain untouched.
+    /// </remarks>
+    public static void FilterWithLanguageVersion<T>(
+        this IncrementalGeneratorInitializationContext context,
+        ref IncrementalValuesProvider<T> source,
+        LanguageVersion languageVersion,
+        DiagnosticDescriptor diagnosticDescriptor)
+    {
+        // Check whether the target language version is supported
+        IncrementalValueProvider<bool> isGeneratorSupported =
+            context.ParseOptionsProvider
+            .Select((item, _) => item is CSharpParseOptions options && options.LanguageVersion >= languageVersion);
+
+        // Combine each data item with the supported flag
+        IncrementalValuesProvider<(T Data, bool IsGeneratorSupported)> dataWithSupportedInfo =
+            source
+            .Combine(isGeneratorSupported);
+
+        // Get a marker node to show whether an invalid attribute is used
+        IncrementalValueProvider<bool> isUnsupportedAttributeUsed =
+            dataWithSupportedInfo
+            .Select(static (item, _) => item.IsGeneratorSupported)
+            .Where(static item => !item)
+            .Collect()
+            .Select(static (item, _) => item.Length > 0);
+
+        // Report them to the output
+        context.RegisterSourceOutput(isUnsupportedAttributeUsed, (context, diagnostic) =>
+        {
+            if (diagnostic)
+            {
+                context.ReportDiagnostic(Diagnostic.Create(diagnosticDescriptor, null));
+            }
+        });
+
+        // Only let data through if the minimum language version is supported
+        source =
+            dataWithSupportedInfo
+            .Where(static item => item.IsGeneratorSupported)
+            .Select(static (item, _) => item.Data);
+    }
+}
diff --git a/CommunityToolkit.Mvvm.SourceGenerators/Input/ICommandGenerator.cs b/CommunityToolkit.Mvvm.SourceGenerators/Input/ICommandGenerator.cs
@@ -26,23 +26,12 @@ public sealed partial class ICommandGenerator : IIncrementalGenerator
     /// <inheritdoc/>
     public void Initialize(IncrementalGeneratorInitializationContext context)
     {
-        // Validate the language version
-        IncrementalValueProvider<bool> isGeneratorSupported =
-            context.ParseOptionsProvider
-            .Select(static (item, _) => item is CSharpParseOptions { LanguageVersion: >= LanguageVersion.CSharp8 });
-
-        // Emit the diagnostic, if needed
-        context.ReportDiagnosticsIsNotSupported(isGeneratorSupported, Diagnostic.Create(UnsupportedCSharpLanguageVersionError, null));
-
         // Get all method declarations with at least one attribute
         IncrementalValuesProvider<IMethodSymbol> methodSymbols =
             context.SyntaxProvider
             .CreateSyntaxProvider(
                 static (node, _) => node is MethodDeclarationSyntax { Parent: ClassDeclarationSyntax, AttributeLists.Count: > 0 },
-                static (context, _) => (IMethodSymbol)context.SemanticModel.GetDeclaredSymbol(context.Node)!)
-            .Combine(isGeneratorSupported)
-            .Where(static item => item.Right)
-            .Select(static (item, _) => item.Left);
+                static (context, _) => (IMethodSymbol)context.SemanticModel.GetDeclaredSymbol(context.Node)!);
 
         // Filter the methods using [ICommand]
         IncrementalValuesProvider<(IMethodSymbol Symbol, AttributeData Attribute)> methodSymbolsWithAttributeData =
@@ -52,6 +41,9 @@ public void Initialize(IncrementalGeneratorInitializationContext context)
                 Attribute: item.GetAttributes().FirstOrDefault(a => a.AttributeClass?.HasFullyQualifiedName("global::CommunityToolkit.Mvvm.Input.ICommandAttribute") == true)))
             .Where(static item => item.Attribute is not null)!;
 
+        // Filter by language version
+        context.FilterWithLanguageVersion(ref methodSymbolsWithAttributeData, LanguageVersion.CSharp8, UnsupportedCSharpLanguageVersionError);
+
         // Gather info for all annotated command methods
         IncrementalValuesProvider<(HierarchyInfo Hierarchy, Result<CommandInfo?> Info)> commandInfoWithErrors =
             methodSymbolsWithAttributeData
diff --git a/CommunityToolkit.Mvvm.SourceGenerators/Messaging/IMessengerRegisterAllGenerator.cs b/CommunityToolkit.Mvvm.SourceGenerators/Messaging/IMessengerRegisterAllGenerator.cs
@@ -22,20 +22,12 @@ public sealed partial class IMessengerRegisterAllGenerator : IIncrementalGenerat
     /// <inheritdoc/>
     public void Initialize(IncrementalGeneratorInitializationContext context)
     {
-        // Validate the language version
-        IncrementalValueProvider<bool> isGeneratorSupported =
-            context.ParseOptionsProvider
-            .Select(static (item, _) => item is CSharpParseOptions { LanguageVersion: >= LanguageVersion.CSharp8 });
-
         // Get all class declarations
         IncrementalValuesProvider<INamedTypeSymbol> typeSymbols =
             context.SyntaxProvider
             .CreateSyntaxProvider(
                 static (node, _) => node is ClassDeclarationSyntax,
-                static (context, _) => (INamedTypeSymbol)context.SemanticModel.GetDeclaredSymbol(context.Node)!)
-            .Combine(isGeneratorSupported)
-            .Where(static item => item.Right)
-            .Select(static (item, _) => item.Left);
+                static (context, _) => (INamedTypeSymbol)context.SemanticModel.GetDeclaredSymbol(context.Node)!);
 
         // Get the target IRecipient<TMessage> interfaces and filter out other types
         IncrementalValuesProvider<(INamedTypeSymbol Type, ImmutableArray<INamedTypeSymbol> Interfaces)> typeAndInterfaceSymbols =
diff --git a/tests/CommunityToolkit.Mvvm.SourceGenerators.UnitTests/Test_SourceGeneratorsDiagnostics.cs b/tests/CommunityToolkit.Mvvm.SourceGenerators.UnitTests/Test_SourceGeneratorsDiagnostics.cs
@@ -304,7 +304,7 @@ public partial class SampleViewModel : ObservableValidator
                 }
             }";
 
-        // This is explicitly allowed in C# < 9.0, as it doesn't use any new features
+        // 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)));
     }
@@ -351,7 +351,7 @@ public void Receive(MyMessage message)
                 }
             }";
 
-        // This is explicitly allowed in C# < 9.0, as it doesn't use any new features
+        // 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)));
     }

Original file line number	Diff line number	Diff line change
`@@ -304,7 +304,7 @@ public partial class SampleViewModel : ObservableValidator`
`304`	`304`	`}`
`305`	`305`	`}";`
`306`	`306`
`307`		`- // This is explicitly allowed in C# < 9.0, as it doesn't use any new features`
	`307`	`+ // This is explicitly allowed in C# < 8.0, as it doesn't use any new features`
`308`	`308`	`VerifyGeneratedDiagnostics<ObservableValidatorValidateAllPropertiesGenerator>(`
`309`	`309`	`CSharpSyntaxTree.ParseText(source, CSharpParseOptions.Default.WithLanguageVersion(LanguageVersion.CSharp7_3)));`
`310`	`310`	`}`
`@@ -351,7 +351,7 @@ public void Receive(MyMessage message)`
`351`	`351`	`}`
`352`	`352`	`}";`
`353`	`353`
`354`		`- // This is explicitly allowed in C# < 9.0, as it doesn't use any new features`
	`354`	`+ // This is explicitly allowed in C# < 8.0, as it doesn't use any new features`
`355`	`355`	`VerifyGeneratedDiagnostics<IMessengerRegisterAllGenerator>(`
`356`	`356`	`CSharpSyntaxTree.ParseText(source, CSharpParseOptions.Default.WithLanguageVersion(LanguageVersion.CSharp7_3)));`
`357`	`357`	`}`