Optimize _is_java_ident_byte

The optimization achieves a **31% runtime improvement** (from 6.05ms to 4.60ms) by eliminating repeated `ord()` function calls through precomputation of ASCII values at module load time.

**Key Changes:**
- Moved all `ord()` calls from inside the function to module-level constants (`_a`, `_z`, `_A`, `_Z`, `_0`, `_9`, `_UNDERSCORE`, `_DOLLAR`)
- The comparison logic remains identical, but now uses precomputed integer constants instead of calling `ord()` on every invocation

**Why This Is Faster:**
In Python, function calls have significant overhead. The original code called `ord()` up to 10 times per function invocation (twice per range check for short-circuit evaluation). The line profiler shows this overhead clearly - the original version spent 45% of time on the first comparison line alone, much of which was `ord("a")` and `ord("z")` calls.

By precomputing these values once at module import, each call to `_is_java_ident_byte()` now performs only integer comparisons, which are extremely fast CPU operations. This eliminates 8-10 function calls per invocation.

**Performance Characteristics:**
The optimization provides consistent speedups across all test scenarios:
- **16-27% faster** for valid identifier bytes (lowercase, uppercase, digits)
- **30-50% faster** for boundary and invalid cases that short-circuit early
- **40-54% faster** for bulk operations testing many sequential values (e.g., 42.1% on 0-255 range, 53.8% on large invalid ranges)

This optimization is particularly valuable for workloads that call `_is_java_ident_byte()` frequently in tight loops, such as tokenization, parsing, or validation of Java source code at scale. The function appears to be used in Java bytecode instrumentation, where processing many identifier characters quickly is critical for performance.

Author: codeflash-ai[bot]

codeflash/languages/java/instrumentation.py

@@ -31,6 +31,22 @@
     from codeflash.discovery.functions_to_optimize import FunctionToOptimize
     from codeflash.languages.java.parser import JavaAnalyzer
 
+_A = ord("A")
+
+_Z = ord("Z")
+
+_a = ord("a")
+
+_z = ord("z")
+
+_0 = ord("0")
+
+_9 = ord("9")
+
+_UNDERSCORE = ord("_")
+
+_DOLLAR = ord("$")
+
 _WORD_RE = re.compile(r"^\w+$")
 
 _ASSERTION_METHODS = ("assertArrayEquals", "assertArrayNotEquals")
@@ -229,11 +245,11 @@ def _collect_test_methods(
 def _is_java_ident_byte(b: int) -> bool:
     """Check if a byte represents a Java identifier character (ASCII subset)."""
     return (
-        (ord("a") <= b <= ord("z"))
-        or (ord("A") <= b <= ord("Z"))
-        or (ord("0") <= b <= ord("9"))
-        or b == ord("_")
-        or b == ord("$")
+        (_a <= b <= _z)
+        or (_A <= b <= _Z)
+        or (_0 <= b <= _9)
+        or b == _UNDERSCORE
+        or b == _DOLLAR
     )