fix(csi): sort ArgumentSpecification by index when generating partial-argument advice

Stream.sorted() without a comparator requires Comparable, but
ArgumentSpecification does not implement it. This caused a
ClassCastException in AdviceGeneratorImpl.writeStackOperations whenever
an advice method captured a strict subset (≥2 args) of a target
method's parameters positionally — e.g. capturing args 0 and 1 from a
3-arg target method.

Single-argument partial captures were unaffected because TimSort never
calls compare() on a one-element list.

Fix: use Comparator.comparingInt on ArgumentSpecification.getIndex().
Add a regression test with a @before advice that captures two of three
arguments from String.format(Locale, String, Object[]).

Author: jandro996

buildSrc/call-site-instrumentation-plugin/src/main/java/datadog/trace/plugin/csi/impl/AdviceGeneratorImpl.java

@@ -58,6 +58,7 @@
 import java.io.File;
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Comparator;
 import java.util.List;
 import java.util.stream.Collectors;
 import javax.annotation.Nonnull;
@@ -266,7 +267,7 @@ private static void writeStackOperations(final AdviceSpecification advice, final
       final List<Expression> parameterIndicesValues =
           advice
               .getArguments()
-              .sorted()
+              .sorted(Comparator.comparingInt(argSpec -> argSpec.getIndex()))
               .map(argSpec -> intLiteral(argSpec.getIndex()))
               .collect(Collectors.toList());
       final VariableDeclarator parameterIndices =

buildSrc/call-site-instrumentation-plugin/src/test/java/datadog/trace/plugin/csi/impl/AdviceGeneratorTest.java

@@ -426,6 +426,44 @@ void partialArgumentsWithBeforeAdvice() {
         });
   }
 
+  /**
+   * Captures two of three arguments positionally. Before the fix, this would throw a
+   * ClassCastException because ArgumentSpecification does not implement Comparable and the
+   * generator called Stream.sorted() without an explicit comparator.
+   */
+  @CallSite(spi = CallSites.class)
+  public static class MultiplePartialArgumentsBeforeAdvice {
+    @CallSite.Before(
+        "java.lang.String java.lang.String.format(java.util.Locale, java.lang.String, java.lang.Object[])")
+    public static void before(
+        @CallSite.Argument(0) java.util.Locale locale, @CallSite.Argument(1) String format) {}
+  }
+
+  @Test
+  void multiplePartialArgumentsWithBeforeAdvice() {
+    CallSiteSpecification spec =
+        buildClassSpecification(MultiplePartialArgumentsBeforeAdvice.class);
+    AdviceGenerator generator = buildAdviceGenerator(buildDir);
+
+    CallSiteResult result = generator.generate(spec);
+
+    assertNoErrors(result);
+    CallSiteAssert asserter = assertCallSites(result.getFile());
+    asserter.advices(
+        0,
+        advice -> {
+          advice.pointcut(
+              "java/lang/String",
+              "format",
+              "(Ljava/util/Locale;Ljava/lang/String;[Ljava/lang/Object;)Ljava/lang/String;");
+          advice.statements(
+              "int[] parameterIndices = new int[] { 0, 1 };",
+              "handler.dupParameters(descriptor, parameterIndices, null);",
+              "handler.advice(\"datadog/trace/plugin/csi/impl/AdviceGeneratorTest$MultiplePartialArgumentsBeforeAdvice\", \"before\", \"(Ljava/util/Locale;Ljava/lang/String;)V\");",
+              "handler.method(opcode, owner, name, descriptor, isInterface);");
+        });
+  }
+
   @CallSite(spi = CallSites.class)
   public static class SuperTypeReturnAdvice {
     @CallSite.After("void java.lang.StringBuilder.<init>(java.lang.String)")