Avoid intermediate slice views when reading token text

Lexing and parsing turn code point ranges into strings constantly: once for
every identifier, keyword and literal. Both call sites spelled this as
slice(i, j).toString(), which allocates an intermediate CelCodePointArray view
solely to copy out of it and then discard it.

Add CelCodePointArray.substring(i, j), which builds the String straight from the
backing array, and implement it in each of the four subclasses. toString()
becomes final and delegates to substring(0, size()), so the subclasses lose
their near-duplicate toString() overrides. Lexer.consumeIdent and
PrattParser.getTokenText call the new method.

This removes exactly one 32-byte object per token whose text is materialized.

Measured with CelParserBenchmark (parseOnly, built -c opt), comparing three
parsers back to back in one session: ANTLR, the Pratt parser before this change,
and the Pratt parser after it.

Objects allocated per parse:

| Case | ANTLR | Pratt before | Pratt after | Pratt vs ANTLR | Delta this CL |
| :--- | ---: | ---: | ---: | ---: | ---: |
| SMOKE_TEST | 357 | 123 | 120 | 3.0x smaller | -2.4% |
| CHAINED_ORS | 968 | 349 | 339 | 2.9x smaller | -2.9% |
| LIST_COMPREHENSION | 512 | 166 | 160 | 3.2x smaller | -3.6% |
| MESSAGE_CREATION | 1,253 | 426 | 406 | 3.1x smaller | -4.7% |
| LONG_LIST | 81,794 | 19,265 | 18,263 | 4.5x smaller | -5.2% |

Bytes allocated per parse:

| Case | ANTLR | Pratt before | Pratt after | Pratt vs ANTLR | Delta this CL |
| :--- | ---: | ---: | ---: | ---: | ---: |
| SMOKE_TEST | 12,256 | 3,608 | 3,512 | 3.5x smaller | -2.7% |
| CHAINED_ORS | 32,160 | 9,912 | 9,592 | 3.4x smaller | -3.2% |
| LIST_COMPREHENSION | 17,320 | 4,928 | 4,736 | 3.7x smaller | -3.9% |
| MESSAGE_CREATION | 43,128 | 13,056 | 12,416 | 3.5x smaller | -4.9% |
| LONG_LIST | 2,907,488 | 563,952 | 531,888 | 5.5x smaller | -5.7% |

Wall clock, mean of 3 caliper trial medians:

| Case | ANTLR | Pratt before | Pratt after | Pratt vs ANTLR | Delta this CL |
| :--- | ---: | ---: | ---: | ---: | ---: |
| SMOKE_TEST | 4,940 ns | 696 ns | 684 ns | 7.2x faster | -1.8% |
| CHAINED_ORS | 14,641 ns | 2,008 ns | 2,006 ns | 7.3x faster | -0.1% |
| LIST_COMPREHENSION | 7,514 ns | 1,250 ns | 1,217 ns | 6.2x faster | -2.7% |
| MESSAGE_CREATION | 20,979 ns | 3,526 ns | 3,514 ns | 6.0x faster | -0.4% |
| LONG_LIST | 1,616,631 ns | 140,500 ns | 146,640 ns | 11.0x faster | +4.4% |

Wall clock is unchanged within measurement noise. The per-case deltas run from
-2.7% to +4.4% and straddle zero, which is what a change that removes 3-5% of
allocations and no actual work should look like. The LONG_LIST row reads as a
regression, but that trial was noisy (per-trial medians 144.6us, 155.7us,
139.6us, against a much tighter 142.1us, 141.1us, 138.3us before) and its
fastest observed parse, 134.6us, is below the 135.7us baseline. The win here is
allocation volume and the GC pressure that follows from it. This is the first in
a series of parser changes; the wall-clock improvements come later in that
series.

The ANTLR column is included for scale, and shows why the Pratt parser exists.
ANTLR is slow enough on LONG_LIST that the case exceeds caliper's default 5
minute per-trial budget and has to be measured with a raised --time-limit.

PiperOrigin-RevId: 981290051

Author: dmitriplotnikov

common/src/main/java/dev/cel/common/internal/BasicCodePointArray.java

@@ -58,13 +58,14 @@ public BasicCodePointArray slice(int i, int j) {
   }
 
   @Override
-  public int get(int index) {
-    checkElementIndex(index, size());
-    return codePoints()[offset() + index] & 0xffff;
+  public String substring(int i, int j) {
+    checkPositionIndexes(i, j, size());
+    return new String(codePoints(), offset() + i, j - i);
   }
 
   @Override
-  public final String toString() {
-    return new String(codePoints(), offset(), size());
+  public int get(int index) {
+    checkElementIndex(index, size());
+    return codePoints()[offset() + index] & 0xffff;
   }
 }

common/src/main/java/dev/cel/common/internal/CelCodePointArray.java

@@ -36,6 +36,14 @@ public abstract class CelCodePointArray {
   /** Returns a new {@link CelCodePointArray} that is a subview of this between [i, j). */
   public abstract CelCodePointArray slice(int i, int j);
 
+  /**
+   * Returns the code points between [i, j) as a string.
+   *
+   * <p>Equivalent to {@code slice(i, j).toString()}, but does not materialize the intermediate
+   * view. Lexing and parsing call this for every literal and identifier.
+   */
+  public abstract String substring(int i, int j);
+
   /** Get the code point at the given index. */
   public abstract int get(int index);
 
@@ -55,7 +63,9 @@ public boolean isEmpty() {
   }
 
   @Override
-  public abstract String toString();
+  public final String toString() {
+    return substring(0, size());
+  }
 
   public static CelCodePointArray fromString(String text) {
     if (isNullOrEmpty(text)) {

common/src/main/java/dev/cel/common/internal/EmptyCodePointArray.java

@@ -14,6 +14,8 @@
 
 package dev.cel.common.internal;
 
+import static com.google.common.base.Preconditions.checkPositionIndexes;
+
 import com.google.common.collect.ImmutableList;
 import com.google.errorprone.annotations.DoNotCall;
 import com.google.errorprone.annotations.Immutable;
@@ -51,6 +53,12 @@ public int get(int index) {
         String.format("index (%s) must not be greater than size (0)", index));
   }
 
+  @Override
+  public String substring(int i, int j) {
+    checkPositionIndexes(i, j, 0);
+    return "";
+  }
+
   @Override
   public int size() {
     return 0;
@@ -60,9 +68,4 @@ public int size() {
   public ImmutableList<Integer> lineOffsets() {
     return ImmutableList.of(1);
   }
-
-  @Override
-  public String toString() {
-    return "";
-  }
 }

common/src/main/java/dev/cel/common/internal/Latin1CodePointArray.java

@@ -58,13 +58,14 @@ public Latin1CodePointArray slice(int i, int j) {
   }
 
   @Override
-  public int get(int index) {
-    checkElementIndex(index, size());
-    return Byte.toUnsignedInt(codePoints()[offset() + index]);
+  public String substring(int i, int j) {
+    checkPositionIndexes(i, j, size());
+    return new String(codePoints(), offset() + i, j - i, ISO_8859_1);
   }
 
   @Override
-  public final String toString() {
-    return new String(codePoints(), offset(), size(), ISO_8859_1);
+  public int get(int index) {
+    checkElementIndex(index, size());
+    return Byte.toUnsignedInt(codePoints()[offset() + index]);
   }
 }

common/src/main/java/dev/cel/common/internal/SupplementalCodePointArray.java

@@ -59,13 +59,14 @@ public SupplementalCodePointArray slice(int i, int j) {
   }
 
   @Override
-  public int get(int index) {
-    checkElementIndex(index, size());
-    return codePoints()[offset() + index];
+  public String substring(int i, int j) {
+    checkPositionIndexes(i, j, size());
+    return new String(codePoints(), offset() + i, j - i);
   }
 
   @Override
-  public final String toString() {
-    return new String(codePoints(), offset(), size());
+  public int get(int index) {
+    checkElementIndex(index, size());
+    return codePoints()[offset() + index];
   }
 }

common/src/test/java/dev/cel/common/internal/CelCodePointArrayTest.java

@@ -15,6 +15,7 @@
 package dev.cel.common.internal;
 
 import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.assertThrows;
 
 import com.google.auto.value.AutoValue;
 import com.google.common.collect.ImmutableList;
@@ -39,6 +40,93 @@ public void computeLineOffset(
         .inOrder();
   }
 
+  @Test
+  public void substring_empty() {
+    CelCodePointArray empty = CelCodePointArray.fromString("");
+    assertThat(empty).isInstanceOf(EmptyCodePointArray.class);
+
+    assertThat(empty.substring(0, 0)).isEmpty();
+    assertThrows(IndexOutOfBoundsException.class, () -> empty.substring(0, 1));
+    assertThrows(IndexOutOfBoundsException.class, () -> empty.substring(-1, 0));
+    assertThrows(IndexOutOfBoundsException.class, () -> empty.substring(1, 0));
+    assertThrows(IndexOutOfBoundsException.class, () -> empty.substring(1, 1));
+  }
+
+  @Test
+  public void substring_latin1() {
+    CelCodePointArray latin1 = CelCodePointArray.fromString("hello world");
+    assertThat(latin1).isInstanceOf(Latin1CodePointArray.class);
+
+    assertThat(latin1.substring(0, 5)).isEqualTo("hello");
+    assertThat(latin1.substring(6, 11)).isEqualTo("world");
+    assertThat(latin1.substring(0, 11)).isEqualTo("hello world");
+    assertThat(latin1.substring(3, 3)).isEmpty();
+
+    assertThrows(IndexOutOfBoundsException.class, () -> latin1.substring(-1, 5));
+    assertThrows(IndexOutOfBoundsException.class, () -> latin1.substring(0, 12));
+    assertThrows(IndexOutOfBoundsException.class, () -> latin1.substring(5, 4));
+
+    // Test on a sliced subview to ensure bounds are checked against size(), not the backing buffer
+    // length
+    CelCodePointArray sliced = latin1.slice(1, 4); // "ell", size = 3, buffer length = 11
+    assertThat(sliced.substring(0, 3)).isEqualTo("ell");
+    assertThat(sliced.substring(1, 2)).isEqualTo("l");
+
+    assertThrows(IndexOutOfBoundsException.class, () -> sliced.substring(-1, 2));
+    assertThrows(IndexOutOfBoundsException.class, () -> sliced.substring(0, 4));
+    assertThrows(IndexOutOfBoundsException.class, () -> sliced.substring(2, 1));
+  }
+
+  @Test
+  public void substring_basic() {
+    CelCodePointArray basic = CelCodePointArray.fromString("abc \uff20 def");
+    assertThat(basic).isInstanceOf(BasicCodePointArray.class);
+
+    assertThat(basic.substring(0, 3)).isEqualTo("abc");
+    assertThat(basic.substring(4, 5)).isEqualTo("\uff20");
+    assertThat(basic.substring(6, 9)).isEqualTo("def");
+    assertThat(basic.substring(0, 9)).isEqualTo("abc \uff20 def");
+    assertThat(basic.substring(3, 3)).isEmpty();
+
+    assertThrows(IndexOutOfBoundsException.class, () -> basic.substring(-1, 5));
+    assertThrows(IndexOutOfBoundsException.class, () -> basic.substring(0, 10));
+    assertThrows(IndexOutOfBoundsException.class, () -> basic.substring(5, 4));
+
+    // Test on a sliced subview to ensure bounds are checked against size(), not the backing buffer
+    // length
+    CelCodePointArray sliced = basic.slice(1, 5); // "bc \uff20", size = 4, buffer length = 9
+    assertThat(sliced.substring(0, 4)).isEqualTo("bc \uff20");
+
+    assertThrows(IndexOutOfBoundsException.class, () -> sliced.substring(-1, 2));
+    assertThrows(IndexOutOfBoundsException.class, () -> sliced.substring(0, 5));
+    assertThrows(IndexOutOfBoundsException.class, () -> sliced.substring(2, 1));
+  }
+
+  @Test
+  public void substring_supplemental() {
+    CelCodePointArray supp = CelCodePointArray.fromString(" text 가나다 😦😁😑 ");
+    assertThat(supp).isInstanceOf(SupplementalCodePointArray.class);
+
+    assertThat(supp.substring(0, 5)).isEqualTo(" text");
+    assertThat(supp.substring(10, 13)).isEqualTo("😦😁😑");
+    assertThat(supp.substring(0, supp.size())).isEqualTo(" text 가나다 😦😁😑 ");
+    assertThat(supp.substring(3, 3)).isEmpty();
+
+    assertThrows(IndexOutOfBoundsException.class, () -> supp.substring(-1, 5));
+    int greaterThanSize = supp.size() + 1;
+    assertThrows(IndexOutOfBoundsException.class, () -> supp.substring(0, greaterThanSize));
+    assertThrows(IndexOutOfBoundsException.class, () -> supp.substring(5, 4));
+
+    // Test on a sliced subview to ensure bounds are checked against size(), not the backing buffer
+    // length
+    CelCodePointArray sliced = supp.slice(1, 5); // "text", size = 4, buffer length = 15
+    assertThat(sliced.substring(0, 4)).isEqualTo("text");
+
+    assertThrows(IndexOutOfBoundsException.class, () -> sliced.substring(-1, 2));
+    assertThrows(IndexOutOfBoundsException.class, () -> sliced.substring(0, 5));
+    assertThrows(IndexOutOfBoundsException.class, () -> sliced.substring(2, 1));
+  }
+
   @AutoValue
   abstract static class LineOffsetTestCase {
     abstract String text();

parser/src/main/java/dev/cel/parser/Lexer.java

@@ -635,7 +635,7 @@ private Token consumeIdent() {
       position++;
     }
     int end = position;
-    String word = content.slice(start, end).toString();
+    String word = content.substring(start, end);
     TokenType keywordType = KEYWORDS.get(word);
     if (keywordType != null) {
       return makeToken(keywordType, start, end);

parser/src/main/java/dev/cel/parser/PrattParser.java

@@ -198,7 +198,7 @@ private String getTokenText(Lexer.Token tok) {
       return tok.text;
     }
     if (tok.start >= 0 && tok.end >= tok.start && tok.end <= source.getContent().size()) {
-      return source.getContent().slice(tok.start, tok.end).toString();
+      return source.getContent().substring(tok.start, tok.end);
     }
     return "";
   }