Optimize JavaAssertTransformer._generate_exception_replacement

The optimization achieves a **13% runtime improvement** (2.31ms → 2.04ms) by replacing Python's `str.endswith()` method call with a direct last-character index check (`code_to_run[-1] != ";"` instead of `not code_to_run.endswith(";")`).

**Key optimization:**
The critical change occurs in the lambda body processing path, which is executed in 2,936 out of 3,943 invocations (74% of calls). By replacing the `endswith()` method call with direct indexing, the code eliminates:
- Method lookup overhead for `endswith`
- Internal string comparison logic
- Function call frame allocation

Line profiler data shows the optimized check (`if code_to_run and code_to_run[-1] != ";"`) runs in 964ns versus 1.24μs for the original `endswith()` call—a 22% improvement on this single line that executes nearly 3,000 times per test run.

**Why this works:**
In CPython, direct character indexing (`[-1]`) is implemented as a simple array lookup in the string's internal buffer, while `endswith()` involves:
1. Method attribute lookup on the string object
2. Argument parsing and validation
3. Internal substring comparison logic
4. Return value marshaling

For a single-character comparison, the indexing approach is significantly faster.

**Test results validation:**
The annotated tests show consistent improvements across all test cases:
- Simple lambda bodies: 17-23% faster (test_simple_lambda_body_*)
- Variable assignments: 6-8% faster (test_variable_assignment_*)
- Batch operations: 14-23% faster (test_many_exception_types, test_long_lambda_bodies_batch)

The optimization is particularly effective for workloads with many assertion transformations, as demonstrated by the large-scale tests (1000+ invocations) showing 17-18% improvements.

**Impact:**
Since `JavaAssertTransformer` is used to process Java test code during optimization workflows, this change directly reduces the time to transform assertion-heavy test files. The function processes each assertion statement individually, so files with hundreds of assertions will see cumulative time savings proportional to the assertion count.

Author: codeflash-ai[bot]

codeflash/languages/java/remove_asserts.py

@@ -863,7 +863,8 @@ def _generate_exception_replacement(self, assertion: AssertionMatch) -> str:
         code_to_run = None
         if assertion.lambda_body:
             code_to_run = assertion.lambda_body
-            if not code_to_run.endswith(";"):
+            # Use a direct last-character check instead of .endswith for lower overhead
+            if code_to_run and code_to_run[-1] != ";":
                 code_to_run += ";"
         elif assertion.target_calls:
             call = assertion.target_calls[0]