Disallow new() for non-defaultable types and suppress StyleCop

Funcky.Analyzers/Funcky.Analyzers.Test/NonDefaultableTest.cs

@@ -25,6 +25,7 @@ class Test
                 private void Usage()
                 {
                     _ = default(Foo);
+                    _ = new Foo();
                 }
             }
 
@@ -67,4 +68,39 @@ struct Generic<T> { }
 
         await VerifyCS.VerifyAnalyzerAsync(inputCode + AttributeSource, expectedDiagnostics);
     }
+
+    [Fact]
+    public async Task ParameterlessConstructorInstantiationsOfAnnotatedStructsGetError()
+    {
+        const string inputCode =
+            """
+            using Funcky.CodeAnalysis;
+
+            class Test
+            {
+                private void Usage()
+                {
+                    _ = new Foo();
+                    _ = new Funcky.Generic<int>();
+                }
+            }
+
+            [NonDefaultable]
+            struct Foo { }
+
+            namespace Funcky
+            {
+                [NonDefaultable]
+                struct Generic<T> { }
+            }
+            """;
+
+        DiagnosticResult[] expectedDiagnostics =
+        [
+            VerifyCS.Diagnostic().WithSpan(7, 13, 7, 22).WithArguments("Foo"),
+            VerifyCS.Diagnostic().WithSpan(8, 13, 8, 38).WithArguments("Generic<int>"),
+        ];
+
+        await VerifyCS.VerifyAnalyzerAsync(inputCode + AttributeSource, expectedDiagnostics);
+    }
 }

Funcky.Analyzers/Funcky.Analyzers/NonDefaultableAnalyzer.cs

@@ -17,7 +17,7 @@ public sealed class NonDefaultableAnalyzer : DiagnosticAnalyzer
         isEnabledByDefault: true,
         description: "Values instantiated with default are in an invalid state; any member may throw an exception.");
 
-    private const string AttributeFullName = "Funcky.CodeAnalysis.NonDefaultableAttribute";
+    internal const string AttributeFullName = "Funcky.CodeAnalysis.NonDefaultableAttribute";
 
     public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(DoNotUseDefault);
 
@@ -28,11 +28,16 @@ public override void Initialize(AnalysisContext context)
         context.RegisterCompilationStartAction(OnCompilationStart);
     }
 
+    internal static bool IsParameterlessObjectCreationOfNonDefaultableStruct(IObjectCreationOperation operation, INamedTypeSymbol nonDefaultableAttribute)
+        => operation is { Type: { } type, Arguments.Length: 0, Initializer: null }
+            && type.GetAttributes().Any(IsAttribute(nonDefaultableAttribute));
+
     private static void OnCompilationStart(CompilationStartAnalysisContext context)
     {
         if (context.Compilation.GetTypeByMetadataName(AttributeFullName) is { } nonDefaultableAttribute)
         {
             context.RegisterOperationAction(AnalyzeDefaultValueOperation(nonDefaultableAttribute), OperationKind.DefaultValue);
+            context.RegisterOperationAction(AnalyzeObjectCreationOperation(nonDefaultableAttribute), OperationKind.ObjectCreation);
         }
     }
 
@@ -42,13 +47,26 @@ private static Action<OperationAnalysisContext> AnalyzeDefaultValueOperation(INa
             var operation = (IDefaultValueOperation)context.Operation;
             if (operation.Type is { } type && type.GetAttributes().Any(IsAttribute(nonDefaultableAttribute)))
             {
-                context.ReportDiagnostic(Diagnostic.Create(
-                    DoNotUseDefault,
-                    operation.Syntax.GetLocation(),
-                    messageArgs: type.ToDisplayString(SymbolDisplayFormat.MinimallyQualifiedFormat)));
+                ReportDiagnostic(context);
+            }
+        };
+
+    private static Action<OperationAnalysisContext> AnalyzeObjectCreationOperation(INamedTypeSymbol nonDefaultableAttribute)
+        => context =>
+        {
+            var operation = (IObjectCreationOperation)context.Operation;
+            if (IsParameterlessObjectCreationOfNonDefaultableStruct(operation, nonDefaultableAttribute))
+            {
+                ReportDiagnostic(context);
             }
         };
 
+    private static void ReportDiagnostic(OperationAnalysisContext context)
+        => context.ReportDiagnostic(Diagnostic.Create(
+            DoNotUseDefault,
+            context.Operation.Syntax.GetLocation(),
+            messageArgs: context.Operation.Type?.ToDisplayString(SymbolDisplayFormat.MinimallyQualifiedFormat)));
+
     private static Func<AttributeData, bool> IsAttribute(INamedTypeSymbol attributeClass)
         => attribute => SymbolEqualityComparer.Default.Equals(attribute.AttributeClass, attributeClass);
 }

Funcky.Analyzers/Funcky.Analyzers/NonDefaultableStyleCopSuppressor.cs

@@ -0,0 +1,49 @@
+using System.Collections.Immutable;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Microsoft.CodeAnalysis.Operations;
+using static Funcky.Analyzers.NonDefaultableAnalyzer;
+
+namespace Funcky.Analyzers;
+
+[DiagnosticAnalyzer(LanguageNames.CSharp)]
+public sealed class NonDefaultableStyleCopSuppressor : DiagnosticSuppressor
+{
+    private static readonly SuppressionDescriptor DoNotUseDefaultValueTypeConstructorSuppression = new(
+        "Funcky-Suppress-SA1129",
+        "SA1129",
+        "λ1009 already disallows usage of this constructor.");
+
+    public override ImmutableArray<SuppressionDescriptor> SupportedSuppressions => ImmutableArray.Create(DoNotUseDefaultValueTypeConstructorSuppression);
+
+    public override void ReportSuppressions(SuppressionAnalysisContext context)
+    {
+        if (context.Compilation.GetTypeByMetadataName(AttributeFullName) is { } nonDefaultableAttribute)
+        {
+            ReportSuppressions(context, nonDefaultableAttribute);
+        }
+    }
+
+    private static void ReportSuppressions(SuppressionAnalysisContext context, INamedTypeSymbol nonDefaultableAttribute)
+    {
+        var styleCopDiagnostics = context.ReportedDiagnostics.Where(diagnostic => diagnostic.Id == DoNotUseDefaultValueTypeConstructorSuppression.SuppressedDiagnosticId);
+        foreach (var diagnostic in styleCopDiagnostics)
+        {
+            if (GetOperation(context, diagnostic) is IObjectCreationOperation operation
+                && IsParameterlessObjectCreationOfNonDefaultableStruct(operation, nonDefaultableAttribute))
+            {
+                context.ReportSuppression(Suppression.Create(DoNotUseDefaultValueTypeConstructorSuppression, diagnostic));
+            }
+        }
+    }
+
+    private static IOperation? GetOperation(SuppressionAnalysisContext context, Diagnostic diagnostic)
+    {
+        var location = diagnostic.Location;
+        var syntaxTree = location.SourceTree;
+        return syntaxTree?.GetRoot(context.CancellationToken) is { } root
+            && context.GetSemanticModel(syntaxTree) is { } semanticModel
+                ? semanticModel.GetOperation(root.FindNode(location.SourceSpan))
+                : null;
+    }
+}