Merge pull request #538 from CommunityToolkit/dev/remove-nullability-attributes

Remove nullability attributes generator

Author: Sergio0694

src/CommunityToolkit.Mvvm.SourceGenerators/Attributes/NullabilityAttributesGenerator.cs

@@ -13,14 +13,6 @@
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
       <LogicalName>INotifyPropertyChanged.cs</LogicalName>
     </EmbeddedResource>
-    <EmbeddedResource Include="$(MSBuildThisFileDirectory)EmbeddedResources\NotNullAttribute.cs">
-      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-      <LogicalName>NotNullAttribute.cs</LogicalName>
-    </EmbeddedResource>
-    <EmbeddedResource Include="$(MSBuildThisFileDirectory)EmbeddedResources\NotNullIfNotNullAttribute.cs">
-      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-      <LogicalName>NotNullIfNotNullAttribute.cs</LogicalName>
-    </EmbeddedResource>
     <EmbeddedResource Include="$(MSBuildThisFileDirectory)EmbeddedResources\ObservableObject.cs">
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
       <LogicalName>ObservableObject.cs</LogicalName>
@@ -31,7 +23,6 @@
     </EmbeddedResource>
   </ItemGroup>
   <ItemGroup>
-    <Compile Include="$(MSBuildThisFileDirectory)Attributes\NullabilityAttributesGenerator.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)ComponentModel\INotifyPropertyChangedGenerator.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)ComponentModel\Models\AttributeInfo.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)ComponentModel\Models\INotifyPropertyChangedInfo.cs" />

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

@@ -8,6 +8,7 @@
 using System.Linq;
 using System.Reflection;
 using CommunityToolkit.Mvvm.SourceGenerators.Extensions;
+using CommunityToolkit.Mvvm.SourceGenerators.Helpers;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
@@ -23,6 +24,18 @@ partial class TransitiveMembersGenerator<TInfo>
     /// </summary>
     internal static class Execute
     {
+        /// <summary>
+        /// Checks whether or not nullability attributes are currently available.
+        /// </summary>
+        /// <param name="compilation">The input <see cref="Compilation"/> instance.</param>
+        /// <returns>Whether or not nullability attributes are currently available.</returns>
+        public static bool IsNullabilitySupported(Compilation compilation)
+        {
+            return
+                compilation.HasAccessibleTypeWithMetadataName("System.Diagnostics.CodeAnalysis.NotNullAttribute") &&
+                compilation.HasAccessibleTypeWithMetadataName("System.Diagnostics.CodeAnalysis.NotNullIfNotNullAttribute");
+        }
+
         /// <summary>
         /// Loads the source <see cref="ClassDeclarationSyntax"/> instance to get member declarations from.
         /// </summary>
@@ -68,8 +81,14 @@ public static void ProcessMemberDeclarations(
                             AttributeArgument(LiteralExpression(SyntaxKind.StringLiteralExpression, Literal(generatorType.Assembly.GetName().Version.ToString())))))))
                     .WithLeadingTrivia(member.GetLeadingTrivia());
 
+                // [DebuggerNonUserCode] is not supported on interfaces, fields and event
+                if (member.Kind() is not (SyntaxKind.InterfaceDeclaration or SyntaxKind.FieldDeclaration or SyntaxKind.EventFieldDeclaration))
+                {
+                    member = member.AddAttributeLists(AttributeList(SingletonSeparatedList(Attribute(IdentifierName("global::System.Diagnostics.DebuggerNonUserCode")))));
+                }
+
                 // [ExcludeFromCodeCoverage] is not supported on interfaces and fields
-                if (member.Kind() is not SyntaxKind.InterfaceDeclaration and not SyntaxKind.FieldDeclaration)
+                if (member.Kind() is not (SyntaxKind.InterfaceDeclaration or SyntaxKind.FieldDeclaration))
                 {
                     member = member.AddAttributeLists(AttributeList(SingletonSeparatedList(Attribute(IdentifierName("global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage")))));
                 }
@@ -95,5 +114,67 @@ public static void ProcessMemberDeclarations(
 
             nonSealedMemberDeclarations = annotatedMemberDeclarations;
         }
+
+        /// <summary>
+        /// Adjusts the nullability annotations for generated members, dropping attributes if needed.
+        /// </summary>
+        /// <param name="memberDeclarations">The input sequence of member declarations to generate.</param>
+        /// <param name="isNullabilitySupported">Whether nullability attributes are supported.</param>
+        /// <returns>The updated collection of member declarations to generate.</returns>
+        public static ImmutableArray<MemberDeclarationSyntax> AdjustMemberDeclarationNullabilityAnnotations(
+            ImmutableArray<MemberDeclarationSyntax> memberDeclarations,
+            bool isNullabilitySupported)
+        {
+            // If nullability attributes are supported, there is nothing else to do
+            if (isNullabilitySupported)
+            {
+                return memberDeclarations;
+            }
+
+            using ImmutableArrayBuilder<MemberDeclarationSyntax> builder = ImmutableArrayBuilder<MemberDeclarationSyntax>.Rent();
+
+            NullabilityAdjustmentSyntaxRewriter syntaxRewriter = new();
+
+            // Iterate over all members and adjust the method declarations, if needed
+            foreach (MemberDeclarationSyntax memberDeclaration in memberDeclarations)
+            {
+                if (memberDeclaration is MethodDeclarationSyntax methodDeclaration)
+                {
+                    builder.Add((MethodDeclarationSyntax)syntaxRewriter.Visit(methodDeclaration));
+                }
+                else
+                {
+                    builder.Add(memberDeclaration);
+                }
+            }
+
+            return builder.ToImmutable();
+        }
+
+        /// <summary>
+        /// A custom syntax rewriter that removes nullability attributes from method parameters.
+        /// </summary>
+        private sealed class NullabilityAdjustmentSyntaxRewriter : CSharpSyntaxRewriter
+        {
+            /// <inheritdoc/>
+            public override SyntaxNode? VisitParameter(ParameterSyntax node)
+            {
+                SyntaxNode? updatedNode = base.VisitParameter(node);
+
+                // If the node is a parameter node with a single attribute being either [NotNull] or [NotNullIfNotNull], drop it.
+                // This expression will match all parameters with the following format:
+                //
+                // ([global::<NAMESPACE>.<ATTRIBUTE_NAME>] <TYPE> <PARAMETER_NAME>)
+                //
+                // Where <ATTRIBUTE_NAME> is either "NotNull" or "NotNullIfNotNull". This relies on parameters following this structure
+                // for nullability annotations, but that is fine in this context given the only source files are the embedded ones.
+                if (updatedNode is ParameterSyntax { AttributeLists: [{ Attributes: [{ Name: QualifiedNameSyntax { Right.Identifier.Text: "NotNull" or "NotNullIfNotNull"} }] }] } parameterNode)
+                {
+                    return parameterNode.WithAttributeLists(default);
+                }
+
+                return updatedNode;
+            }
+        }
     }
 }

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

@@ -61,7 +61,7 @@ private protected TransitiveMembersGenerator(string fullyQualifiedAttributeMetad
     public void Initialize(IncrementalGeneratorInitializationContext context)
     {
         // Gather all generation info, and any diagnostics
-        IncrementalValuesProvider<Result<(HierarchyInfo Hierarchy, bool IsSealed, TInfo? Info)>> generationInfoWithErrors =
+        IncrementalValuesProvider<Result<(HierarchyInfo Hierarchy, MetadataInfo? MetadataInfo, TInfo? Info)>> generationInfoWithErrors =
             context.SyntaxProvider
             .ForAttributeWithMetadataName(
                 this.fullyQualifiedAttributeMetadataName,
@@ -81,30 +81,32 @@ public void Initialize(IncrementalGeneratorInitializationContext context)
                     // If there are any diagnostics, there's no need to compute the hierarchy info at all, just return them
                     if (diagnostics.Length > 0)
                     {
-                        return new Result<(HierarchyInfo, bool, TInfo?)>(default, diagnostics);
+                        return new Result<(HierarchyInfo, MetadataInfo?, TInfo?)>(default, diagnostics);
                     }
 
                     HierarchyInfo hierarchy = HierarchyInfo.From(typeSymbol);
+                    MetadataInfo metadataInfo = new(typeSymbol.IsSealed, Execute.IsNullabilitySupported(context.SemanticModel.Compilation));
 
-                    return new Result<(HierarchyInfo, bool, TInfo?)>((hierarchy, typeSymbol.IsSealed, info), diagnostics);
+                    return new Result<(HierarchyInfo, MetadataInfo?, TInfo?)>((hierarchy, metadataInfo, info), diagnostics);
                 })
             .Where(static item => item is not null)!;
 
         // Emit the diagnostic, if needed
         context.ReportDiagnostics(generationInfoWithErrors.Select(static (item, _) => item.Errors));
 
         // Get the filtered sequence to enable caching
-        IncrementalValuesProvider<(HierarchyInfo Hierarchy, bool IsSealed, TInfo Info)> generationInfo =
+        IncrementalValuesProvider<(HierarchyInfo Hierarchy, MetadataInfo MetadataInfo, TInfo Info)> generationInfo =
             generationInfoWithErrors
             .Where(static item => item.Errors.IsEmpty)
             .Select(static (item, _) => item.Value)!;
 
         // Generate the required members
         context.RegisterSourceOutput(generationInfo, (context, item) =>
         {
-            ImmutableArray<MemberDeclarationSyntax> sourceMemberDeclarations = item.IsSealed ? this.sealedMemberDeclarations : this.nonSealedMemberDeclarations;
+            ImmutableArray<MemberDeclarationSyntax> sourceMemberDeclarations = item.MetadataInfo.IsSealed ? this.sealedMemberDeclarations : this.nonSealedMemberDeclarations;
             ImmutableArray<MemberDeclarationSyntax> filteredMemberDeclarations = FilterDeclaredMembers(item.Info, sourceMemberDeclarations);
-            CompilationUnitSyntax compilationUnit = item.Hierarchy.GetCompilationUnit(filteredMemberDeclarations, this.classDeclaration.BaseList);
+            ImmutableArray<MemberDeclarationSyntax> updatedMemberDeclarations = Execute.AdjustMemberDeclarationNullabilityAnnotations(filteredMemberDeclarations, item.MetadataInfo.IsNullabilitySupported);
+            CompilationUnitSyntax compilationUnit = item.Hierarchy.GetCompilationUnit(updatedMemberDeclarations, this.classDeclaration.BaseList);
 
             context.AddSource($"{item.Hierarchy.FilenameHint}.g.cs", compilationUnit.GetText(Encoding.UTF8));
         });
@@ -128,4 +130,11 @@ public void Initialize(IncrementalGeneratorInitializationContext context)
     /// <param name="memberDeclarations">The input sequence of <see cref="MemberDeclarationSyntax"/> instances to generate.</param>
     /// <returns>A sequence of <see cref="MemberDeclarationSyntax"/> nodes to emit in the generated file.</returns>
     protected abstract ImmutableArray<MemberDeclarationSyntax> FilterDeclaredMembers(TInfo info, ImmutableArray<MemberDeclarationSyntax> memberDeclarations);
-}
+
+    /// <summary>
+    /// A small record for metadata info on types to generate.
+    /// </summary>
+    /// <param name="IsSealed">Whether the target type is sealed.</param>
+    /// <param name="IsNullabilitySupported">Whether nullability attributes are supported.</param>
+    private sealed record MetadataInfo(bool IsSealed, bool IsNullabilitySupported);
+}

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

@@ -1639,7 +1639,6 @@ private static async Task VerifyAnalyzerDiagnosticsAndSuccessfulGeneration<TAnal
         IIncrementalGenerator[] generators =
         {
             new IMessengerRegisterAllGenerator(),
-            new NullabilityAttributesGenerator(),
             new ObservableObjectGenerator(),
             new INotifyPropertyChangedGenerator(),
             new ObservablePropertyGenerator(),