Add separate rethrow diagnostic message and remove duplicate test

Rethrows (`throw;`) now get a distinct message advising to extract the
try/catch block instead of the generic ThrowHelper advice that doesn't
apply. Remove duplicate ShouldFixThrowExpression test (identical to
ShouldFixNullCoalesceThrowExpressionInReturn).

🤖 Co-Authored-By: Claude Code <noreply@anthropic.com>

Author: lucaspimentel

tracer/src/Datadog.Trace.Tools.Analyzers/ThrowInInlinedMethodAnalyzer/Diagnostics.cs

@@ -27,5 +27,14 @@ public static class Diagnostics
         defaultSeverity: DiagnosticSeverity.Warning,
         isEnabledByDefault: false,
         description: "throw statements prevent the JIT from inlining a method. Move the throw to a separate helper method marked with [MethodImpl(MethodImplOptions.NoInlining)] and [DoesNotReturn].");
+
+    internal static readonly DiagnosticDescriptor RethrowInAggressiveInliningRule = new(
+        DiagnosticId,
+        title: "Avoid throw in AggressiveInlining method",
+        messageFormat: "Method '{0}' is marked [AggressiveInlining] but contains a rethrow statement, which prevents inlining. Extract the try/catch block to a separate non-inlined method.",
+        category: "Performance",
+        defaultSeverity: DiagnosticSeverity.Warning,
+        isEnabledByDefault: false,
+        description: "throw statements (including rethrows) prevent the JIT from inlining a method. Move the try/catch block to a separate method marked with [MethodImpl(MethodImplOptions.NoInlining)].");
 #pragma warning restore RS2008
 }

tracer/src/Datadog.Trace.Tools.Analyzers/ThrowInInlinedMethodAnalyzer/ThrowInInlinedMethodAnalyzer.cs

@@ -25,7 +25,7 @@ public class ThrowInInlinedMethodAnalyzer : DiagnosticAnalyzer
 
     /// <inheritdoc/>
     public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics
-        => ImmutableArray.Create(Diagnostics.ThrowInAggressiveInliningRule);
+        => ImmutableArray.Create(Diagnostics.ThrowInAggressiveInliningRule, Diagnostics.RethrowInAggressiveInliningRule);
 
     /// <inheritdoc/>
     public override void Initialize(AnalysisContext context)
@@ -56,14 +56,17 @@ private static void AnalyzeThrow(SyntaxNodeAnalysisContext context)
         if (HasAggressiveInlining(methodSymbol))
         {
             var memberName = GetMemberDisplayName(containingMember);
-            var diagnostic = Diagnostic.Create(
-                Diagnostics.ThrowInAggressiveInliningRule,
-                throwNode.GetLocation(),
-                memberName);
+            var rule = IsRethrow(throwNode)
+                ? Diagnostics.RethrowInAggressiveInliningRule
+                : Diagnostics.ThrowInAggressiveInliningRule;
+            var diagnostic = Diagnostic.Create(rule, throwNode.GetLocation(), memberName);
             context.ReportDiagnostic(diagnostic);
         }
     }
 
+    private static bool IsRethrow(SyntaxNode throwNode)
+        => throwNode is ThrowStatementSyntax { Expression: null };
+
     private static SyntaxNode? GetContainingMember(SyntaxNode node)
     {
         for (var current = node.Parent; current is not null; current = current.Parent)

tracer/test/Datadog.Trace.Tools.Analyzers.Tests/ThrowInInlinedMethodAnalyzer/ThrowInInlinedMethodCodeFixProviderTests.cs

@@ -308,49 +308,6 @@ void TestMethod()
         await Verifier.VerifyCodeFixAsync(source + ThrowHelperStub, expected, fix + ThrowHelperStub);
     }
 
-    [Fact]
-    public async Task ShouldFixThrowExpression()
-    {
-        // Throw expressions in null-coalescing are converted to if-statements
-        const string source = """
-            using System;
-            using System.Runtime.CompilerServices;
-
-            class TestClass
-            {
-                [MethodImpl(MethodImplOptions.AggressiveInlining)]
-                object TestMethod(object? arg)
-                {
-                    return arg ?? {|#0:throw new ArgumentNullException(nameof(arg))|};
-                }
-            }
-            """;
-
-        const string fix = """
-            using System;
-            using System.Runtime.CompilerServices;
-            using Datadog.Trace.Util;
-
-            class TestClass
-            {
-                [MethodImpl(MethodImplOptions.AggressiveInlining)]
-                object TestMethod(object? arg)
-                {
-                    if (arg is null)
-                    {
-                        ThrowHelper.ThrowArgumentNullException(nameof(arg));
-                    }
-                    return arg;
-                }
-            }
-            """;
-
-        var expected = new DiagnosticResult(DiagnosticId, DiagnosticSeverity.Warning)
-            .WithLocation(0)
-            .WithArguments("TestMethod");
-        await Verifier.VerifyCodeFixAsync(source + ThrowHelperStub, expected, fix + ThrowHelperStub);
-    }
-
     [Fact]
     public async Task ShouldNotFixBareThrow()
     {