Merge pull request #79 from marinasundstrom/feature/implicit-object-creation

Handle implicit object creation expressions #76

Author: marinasundstrom

CheckedExceptions.Tests/CheckedExceptionsAnalyzerTests.Constructors.cs

@@ -0,0 +1,47 @@
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.Testing;
+
+namespace Sundstrom.CheckedExceptions.Tests;
+
+using Verifier = CSharpAnalyzerVerifier<CheckedExceptionsAnalyzer, DefaultVerifier>;
+
+partial class CheckedExceptionsAnalyzerTests
+{
+    [Fact]
+    public async Task ThrowingConstructor_WithThrowsAttribute_ShouldReportDiagnostics_WhenCallerDoesNotHandleOrDeclare()
+    {
+        var test = /* lang=c#-test */ """
+        using System;
+
+        public class ThrowingObject
+        {
+            [Throws(typeof(InvalidOperationException))]
+            public ThrowingObject()
+            {
+                throw new InvalidOperationException();
+            }
+        }
+
+        public class TestClass
+        {
+            public void ExplicitNew()
+            {
+                ThrowingObject obj = new ThrowingObject(); // ❗ Expect diagnostic
+            }
+
+            public void TargetTypedNew()
+            {
+                ThrowingObject obj = new(); // ❗ Expect diagnostic
+            }
+        }
+        """;
+
+        var expected1 = Verifier.MightBeThrown("InvalidOperationException")
+            .WithSpan(16, 30, 16, 50); // new ThrowingObject()
+
+        var expected2 = Verifier.MightBeThrown("InvalidOperationException")
+            .WithSpan(21, 30, 21, 35); // new()
+
+        await Verifier.VerifyAnalyzerAsync(test, expected1, expected2);
+    }
+}

CheckedExceptions/CheckedExceptionsAnalyzer.cs

@@ -113,6 +113,7 @@ public override void Initialize(AnalysisContext context)
         // Register additional actions for method calls, object creations, etc.
         context.RegisterSyntaxNodeAction(AnalyzeMethodCall, SyntaxKind.InvocationExpression);
         context.RegisterSyntaxNodeAction(AnalyzeObjectCreation, SyntaxKind.ObjectCreationExpression);
+        context.RegisterSyntaxNodeAction(AnalyzeImplicitObjectCreation, SyntaxKind.ImplicitObjectCreationExpression);
         context.RegisterSyntaxNodeAction(AnalyzeIdentifier, SyntaxKind.IdentifierName);
         context.RegisterSyntaxNodeAction(AnalyzeMemberAccess, SyntaxKind.SimpleMemberAccessExpression);
         context.RegisterSyntaxNodeAction(AnalyzeAwait, SyntaxKind.AwaitExpression);
@@ -810,6 +811,23 @@ private void AnalyzeObjectCreation(SyntaxNodeAnalysisContext context)
         AnalyzeMemberExceptions(context, objectCreation, constructorSymbol, settings);
     }
 
+
+    /// <summary>
+    /// Analyzes implicit object creation expressions to determine if exceptions are handled or declared.
+    /// </summary>
+    private void AnalyzeImplicitObjectCreation(SyntaxNodeAnalysisContext context)
+    {
+        var settings = GetAnalyzerSettings(context.Options);
+
+        var objectCreation = (ImplicitObjectCreationExpressionSyntax)context.Node;
+
+        var constructorSymbol = context.SemanticModel.GetSymbolInfo(objectCreation).Symbol as IMethodSymbol;
+        if (constructorSymbol is null)
+            return;
+
+        AnalyzeMemberExceptions(context, objectCreation, constructorSymbol, settings);
+    }
+
     /// <summary>
     /// Analyzes member access expressions (e.g., property accessors) for exception handling.
     /// </summary>

Test/Cases/Constructors/Constructors.cs

@@ -48,4 +48,21 @@ public void ProcessData2()
             Console.WriteLine("Handled exception: " + ex.Message);
         }
     }
+
+    public void ProcessData3()
+    {
+        DataFetcher3 fetcher = new();
+    }
+
+    public void ProcessData4()
+    {
+        try
+        {
+            DataFetcher3 fetcher = new();
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine("Handled exception: " + ex.Message);
+        }
+    }
 }

Test/Cases/Constructors/ImplicitObjectCreationTest.cs

@@ -0,0 +1,15 @@
+namespace Test.Cases.Constructors;
+
+public class ImplicitObjectCreationTest
+{
+    [Throws(typeof(InvalidOperationException))]
+    public ImplicitObjectCreationTest()
+    {
+        throw new InvalidOperationException("Constructor exception.");
+    }
+
+    public static void Test()
+    {
+        ImplicitObjectCreationTest foo = new();
+    }
+}