Create a builder for CelEvaluationException

PiperOrigin-RevId: 719430537

bundle/src/test/java/dev/cel/bundle/BUILD.bazel

@@ -32,6 +32,7 @@ java_library(
         "//parser",
         "//parser:macro",
         "//runtime",
+        "//runtime:evaluation_exception_builder",
         "//runtime:unknown_attributes",
         "@cel_spec//proto/cel/expr:expr_java_proto",
         "@cel_spec//proto/cel/expr/conformance/proto2:test_all_types_java_proto",

bundle/src/test/java/dev/cel/bundle/CelImplTest.java

@@ -92,6 +92,7 @@
 import dev.cel.runtime.CelAttribute.Qualifier;
 import dev.cel.runtime.CelAttributePattern;
 import dev.cel.runtime.CelEvaluationException;
+import dev.cel.runtime.CelEvaluationExceptionBuilder;
 import dev.cel.runtime.CelRuntime;
 import dev.cel.runtime.CelRuntime.CelFunctionBinding;
 import dev.cel.runtime.CelRuntime.Program;
@@ -754,8 +755,9 @@ public void program_withThrowingFunctionShortcircuited() throws Exception {
                     "throws",
                     ImmutableList.of(),
                     (args) -> {
-                      throw new CelEvaluationException(
-                          "this method always throws", new RuntimeException("reason"));
+                      throw CelEvaluationExceptionBuilder.newBuilder("this method always throws")
+                          .setCause(new RuntimeException("reason"))
+                          .build();
                     }))
             .setResultType(SimpleType.BOOL)
             .build();

extensions/src/main/java/dev/cel/extensions/BUILD.bazel

@@ -40,6 +40,7 @@ java_library(
         "//common/types",
         "//compiler:compiler_builder",
         "//runtime",
+        "//runtime:evaluation_exception_builder",
         "@maven//:com_google_errorprone_error_prone_annotations",
         "@maven//:com_google_guava_guava",
     ],

extensions/src/main/java/dev/cel/extensions/CelStringExtensions.java

@@ -32,6 +32,7 @@
 import dev.cel.common.types.SimpleType;
 import dev.cel.compiler.CelCompilerLibrary;
 import dev.cel.runtime.CelEvaluationException;
+import dev.cel.runtime.CelEvaluationExceptionBuilder;
 import dev.cel.runtime.CelRuntime;
 import dev.cel.runtime.CelRuntimeBuilder;
 import dev.cel.runtime.CelRuntimeLibrary;
@@ -264,17 +265,20 @@ private static String charAt(String s, long i) throws CelEvaluationException {
     try {
       index = Math.toIntExact(i);
     } catch (ArithmeticException e) {
-      throw new CelEvaluationException(
-          String.format("charAt failure: Index must not exceed the int32 range: %d", i), e);
+      throw CelEvaluationExceptionBuilder.newBuilder(
+              "charAt failure: Index must not exceed the int32 range: %d", i)
+          .setCause(e)
+          .build();
     }
 
     CelCodePointArray codePointArray = CelCodePointArray.fromString(s);
     if (index == codePointArray.length()) {
       return "";
     }
     if (index < 0 || index > codePointArray.length()) {
-      throw new CelEvaluationException(
-          String.format("charAt failure: Index out of range: %d", index));
+      throw CelEvaluationExceptionBuilder.newBuilder(
+              "charAt failure: Index out of range: %d", index)
+          .build();
     }
 
     return codePointArray.slice(index, index + 1).toString();
@@ -296,10 +300,10 @@ private static Long indexOf(Object[] args) throws CelEvaluationException {
     try {
       offset = Math.toIntExact(offsetInLong);
     } catch (ArithmeticException e) {
-      throw new CelEvaluationException(
-          String.format(
-              "indexOf failure: Offset must not exceed the int32 range: %d", offsetInLong),
-          e);
+      throw CelEvaluationExceptionBuilder.newBuilder(
+              "indexOf failure: Offset must not exceed the int32 range: %d", offsetInLong)
+          .setCause(e)
+          .build();
     }
 
     return indexOf(str, substr, offset);
@@ -314,8 +318,9 @@ private static Long indexOf(String str, String substr, int offset) throws CelEva
     CelCodePointArray substrCpa = CelCodePointArray.fromString(substr);
 
     if (offset < 0 || offset >= strCpa.length()) {
-      throw new CelEvaluationException(
-          String.format("indexOf failure: Offset out of range: %d", offset));
+      throw CelEvaluationExceptionBuilder.newBuilder(
+              "indexOf failure: Offset out of range: %d", offset)
+          .build();
     }
 
     return safeIndexOf(strCpa, substrCpa, offset);
@@ -376,14 +381,16 @@ private static Long lastIndexOf(CelCodePointArray str, CelCodePointArray substr,
     try {
       off = Math.toIntExact(offset);
     } catch (ArithmeticException e) {
-      throw new CelEvaluationException(
-          String.format("lastIndexOf failure: Offset must not exceed the int32 range: %d", offset),
-          e);
+      throw CelEvaluationExceptionBuilder.newBuilder(
+              "lastIndexOf failure: Offset must not exceed the int32 range: %d", offset)
+          .setCause(e)
+          .build();
     }
 
     if (off < 0 || off >= str.length()) {
-      throw new CelEvaluationException(
-          String.format("lastIndexOf failure: Offset out of range: %d", offset));
+      throw CelEvaluationExceptionBuilder.newBuilder(
+              "lastIndexOf failure: Offset out of range: %d", offset)
+          .build();
     }
 
     if (off > str.length() - substr.length()) {
@@ -416,9 +423,10 @@ private static String replace(Object[] objects) throws CelEvaluationException {
     try {
       index = Math.toIntExact(indexInLong);
     } catch (ArithmeticException e) {
-      throw new CelEvaluationException(
-          String.format("replace failure: Index must not exceed the int32 range: %d", indexInLong),
-          e);
+      throw CelEvaluationExceptionBuilder.newBuilder(
+              "replace failure: Index must not exceed the int32 range: %d", indexInLong)
+          .setCause(e)
+          .build();
     }
 
     return replace((String) objects[0], (String) objects[1], (String) objects[2], index);
@@ -473,9 +481,10 @@ private static List<String> split(Object[] args) throws CelEvaluationException {
     try {
       limit = Math.toIntExact(limitInLong);
     } catch (ArithmeticException e) {
-      throw new CelEvaluationException(
-          String.format("split failure: Limit must not exceed the int32 range: %d", limitInLong),
-          e);
+      throw CelEvaluationExceptionBuilder.newBuilder(
+              "split failure: Limit must not exceed the int32 range: %d", limitInLong)
+          .setCause(e)
+          .build();
     }
 
     return split((String) args[0], (String) args[1], limit);
@@ -536,18 +545,20 @@ private static Object substring(String s, long i) throws CelEvaluationException
     try {
       beginIndex = Math.toIntExact(i);
     } catch (ArithmeticException e) {
-      throw new CelEvaluationException(
-          String.format("substring failure: Index must not exceed the int32 range: %d", i), e);
+      throw CelEvaluationExceptionBuilder.newBuilder(
+              "substring failure: Index must not exceed the int32 range: %d", i)
+          .setCause(e)
+          .build();
     }
 
     CelCodePointArray codePointArray = CelCodePointArray.fromString(s);
 
     boolean indexIsInRange = beginIndex <= codePointArray.length() && beginIndex >= 0;
     if (!indexIsInRange) {
-      throw new CelEvaluationException(
-          String.format(
+      throw CelEvaluationExceptionBuilder.newBuilder(
               "substring failure: Range [%d, %d) out of bounds",
-              beginIndex, codePointArray.length()));
+              beginIndex, codePointArray.length())
+          .build();
     }
 
     if (beginIndex == codePointArray.length()) {
@@ -569,11 +580,11 @@ private static String substring(Object[] args) throws CelEvaluationException {
       beginIndex = Math.toIntExact(beginIndexInLong);
       endIndex = Math.toIntExact(endIndexInLong);
     } catch (ArithmeticException e) {
-      throw new CelEvaluationException(
-          String.format(
+      throw CelEvaluationExceptionBuilder.newBuilder(
               "substring failure: Indices must not exceed the int32 range: [%d, %d)",
-              beginIndexInLong, endIndexInLong),
-          e);
+              beginIndexInLong, endIndexInLong)
+          .setCause(e)
+          .build();
     }
 
     String s = (String) args[0];
@@ -585,8 +596,9 @@ private static String substring(Object[] args) throws CelEvaluationException {
             && beginIndex <= codePointArray.length()
             && endIndex <= codePointArray.length();
     if (!indicesIsInRange) {
-      throw new CelEvaluationException(
-          String.format("substring failure: Range [%d, %d) out of bounds", beginIndex, endIndex));
+      throw CelEvaluationExceptionBuilder.newBuilder(
+              "substring failure: Range [%d, %d) out of bounds", beginIndex, endIndex)
+          .build();
     }
 
     if (beginIndex == endIndex) {

runtime/BUILD.bazel

@@ -10,9 +10,15 @@ java_library(
     exports = [
         "//runtime/src/main/java/dev/cel/runtime",
         "//runtime/src/main/java/dev/cel/runtime:evaluation_exception",
+        "//runtime/src/main/java/dev/cel/runtime:metadata",
     ],
 )
 
+java_library(
+    name = "evaluation_exception_builder",
+    exports = ["//runtime/src/main/java/dev/cel/runtime:evaluation_exception_builder"],
+)
+
 java_library(
     name = "interpreter",
     exports = ["//runtime/src/main/java/dev/cel/runtime:interpreter"],
@@ -46,5 +52,8 @@ java_library(
 
 java_library(
     name = "base",
-    exports = ["//runtime/src/main/java/dev/cel/runtime:base"],
+    exports = [
+        "//runtime/src/main/java/dev/cel/runtime:base",
+        "//runtime/src/main/java/dev/cel/runtime:metadata",
+    ],
 )

runtime/src/main/java/dev/cel/runtime/BUILD.bazel

@@ -14,7 +14,6 @@ BASE_SOURCES = [
     "FunctionOverload.java",
     "InterpreterException.java",
     "MessageProvider.java",
-    "Metadata.java",
     "Registrar.java",
     "ResolvedOverload.java",
 ]
@@ -56,6 +55,7 @@ java_library(
     tags = [
     ],
     deps = [
+        ":metadata",
         "//:auto_value",
         "//common",
         "//common:error_codes",
@@ -81,6 +81,7 @@ java_library(
         ":base",
         ":cel_type_resolver",
         ":evaluation_listener",
+        ":metadata",
         ":runtime_helper",
         ":unknown_attributes",
         "//:auto_value",
@@ -150,12 +151,41 @@ RUNTIME_SOURCES = [
 
 java_library(
     name = "evaluation_exception",
-    srcs = ["CelEvaluationException.java"],
+    srcs = [
+        "CelEvaluationException.java",
+    ],
     tags = [
     ],
     deps = [
         "//common",
         "//common:error_codes",
+        "@maven//:org_jspecify_jspecify",
+    ],
+)
+
+java_library(
+    name = "evaluation_exception_builder",
+    srcs = ["CelEvaluationExceptionBuilder.java"],
+    tags = [
+    ],
+    deps = [
+        ":evaluation_exception",
+        ":metadata",
+        "//common:error_codes",
+        "//common/annotations",
+        "//common/internal:safe_string_formatter",
+        "@maven//:com_google_errorprone_error_prone_annotations",
+        "@maven//:com_google_guava_guava",
+        "@maven//:org_jspecify_jspecify",
+    ],
+)
+
+java_library(
+    name = "metadata",
+    srcs = ["Metadata.java"],
+    deps = [
+        "//common/annotations",
+        "@maven//:com_google_errorprone_error_prone_annotations",
     ],
 )
 
@@ -166,6 +196,7 @@ java_library(
     ],
     deps = [
         ":evaluation_exception",
+        ":evaluation_exception_builder",
         ":evaluation_listener",
         ":runtime_helper",
         ":runtime_type_provider_legacy",

runtime/src/main/java/dev/cel/runtime/CelEvaluationException.java

@@ -16,6 +16,7 @@
 
 import dev.cel.common.CelErrorCode;
 import dev.cel.common.CelException;
+import org.jspecify.annotations.Nullable;
 
 /**
  * CelEvaluationException encapsulates the potential issues which could arise during the
@@ -24,27 +25,14 @@
 public final class CelEvaluationException extends CelException {
 
   public CelEvaluationException(String message) {
-    super(formatErrorMessage(message));
+    super(message);
   }
 
-  public CelEvaluationException(String message, Throwable cause) {
-    super(formatErrorMessage(message), cause);
+  public CelEvaluationException(String message, @Nullable Throwable cause) {
+    super(message, cause);
   }
 
-  public CelEvaluationException(String message, CelErrorCode errorCode) {
-    super(formatErrorMessage(message), errorCode);
-  }
-
-  public CelEvaluationException(String message, Throwable cause, CelErrorCode errorCode) {
-    this(message, cause, errorCode, true);
-  }
-
-  CelEvaluationException(
-      String message, Throwable cause, CelErrorCode errorCode, boolean formatErrorMessage) {
-    super(formatErrorMessage ? formatErrorMessage(message) : message, cause, errorCode);
-  }
-
-  private static String formatErrorMessage(String message) {
-    return String.format("evaluation error: %s", message);
+  CelEvaluationException(String message, @Nullable Throwable cause, CelErrorCode errorCode) {
+    super(message, cause, errorCode);
   }
 }