Fix ClassCastException in CSI generator when advice captures multiple partial arguments (#11130)

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[]).

fix(csi): remove incorrect Stream.sorted() from partial-argument index generation

Stream.sorted() without a comparator requires Comparable, but
ArgumentSpecification does not implement it, causing ClassCastException
when an advice method captures two or more arguments positionally from a
target method that has strictly more parameters.

The parameters map is a TreeMap keyed by advice-parameter index, so
Stream.sorted() was both redundant and incorrect: it would have
re-sorted by natural order (broken) or by pointcut index (wrong for
advices that intentionally reorder captures). Removing it preserves the
TreeMap's advice-parameter-index order, which is what dupParameters
and the advice descriptor both expect.

Add MultiplePartialArgumentsBeforeAdvice with two variants:
- In-order capture (args 0,1 from 3-arg method): generates {0,1}
- Reversed capture (arg 1 then arg 0): generates {1,0} not {0,1},
  proving parameterIndices follows advice-parameter order.

Merge branch 'master' into fix/csi-generator-partial-args-sort

Co-authored-by: devflow.devflow-routing-intake <devflow.devflow-routing-intake@kubernetes.us1.ddbuild.io>

Author: jandro996

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

@@ -266,7 +266,6 @@ private static void writeStackOperations(final AdviceSpecification advice, final
       final List<Expression> parameterIndicesValues =
           advice
               .getArguments()
-              .sorted()
               .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,71 @@ void partialArgumentsWithBeforeAdvice() {
         });
   }
 
+  /**
+   * Captures two of three arguments positionally. Before the fix, Stream.sorted() without a
+   * comparator threw ClassCastException (ArgumentSpecification is not Comparable). The parameters
+   * TreeMap is keyed by advice-parameter index, so the stream is already in the correct order —
+   * sorted() must not be called. The reversed case verifies that parameterIndices follows the
+   * advice signature order, not the pointcut index order.
+   */
+  @CallSite(spi = CallSites.class)
+  public static class MultiplePartialArgumentsBeforeAdvice {
+    /** Captures args 0 and 1 in the same order as the pointcut. */
+    @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) {}
+
+    /**
+     * Captures the same two args but with their advice positions reversed. parameterIndices must be
+     * {1, 0} (advice order), not {0, 1} (pointcut index order).
+     */
+    @CallSite.Before(
+        "java.lang.String java.lang.String.format(java.util.Locale, java.lang.String, java.lang.Object[])")
+    public static void beforeReversed(
+        @CallSite.Argument(1) String format, @CallSite.Argument(0) java.util.Locale locale) {}
+  }
+
+  @Test
+  void multiplePartialArgumentsWithBeforeAdvice() {
+    CallSiteSpecification spec =
+        buildClassSpecification(MultiplePartialArgumentsBeforeAdvice.class);
+    AdviceGenerator generator = buildAdviceGenerator(buildDir);
+
+    CallSiteResult result = generator.generate(spec);
+
+    assertNoErrors(result);
+    CallSiteAssert asserter = assertCallSites(result.getFile());
+    // In-order capture: {0, 1} matches both advice and pointcut order
+    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);");
+        });
+    // Reversed capture: {1, 0} follows the advice signature, not the pointcut index order {0, 1}
+    asserter.advices(
+        1,
+        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[] { 1, 0 };",
+              "handler.dupParameters(descriptor, parameterIndices, null);",
+              "handler.advice(\"datadog/trace/plugin/csi/impl/AdviceGeneratorTest$MultiplePartialArgumentsBeforeAdvice\", \"beforeReversed\", \"(Ljava/lang/String;Ljava/util/Locale;)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)")