Improve the error message in planned CreateMap when duplicate key exists

PiperOrigin-RevId: 851474395

Author: l46kok

common/exceptions/BUILD.bazel

@@ -53,6 +53,12 @@ java_library(
     exports = ["//common/src/main/java/dev/cel/common/exceptions:iteration_budget_exceeded"],
 )
 
+java_library(
+    name = "duplicate_key",
+    # used_by_android
+    exports = ["//common/src/main/java/dev/cel/common/exceptions:duplicate_key"],
+)
+
 java_library(
     name = "overload_not_found",
     # used_by_android

common/src/main/java/dev/cel/common/exceptions/BUILD.bazel

@@ -111,6 +111,19 @@ java_library(
     ],
 )
 
+java_library(
+    name = "duplicate_key",
+    srcs = ["CelDuplicateKeyException.java"],
+    # used_by_android
+    tags = [
+    ],
+    deps = [
+        ":runtime_exception",
+        "//common:error_codes",
+        "//common/annotations",
+    ],
+)
+
 java_library(
     name = "overload_not_found",
     srcs = ["CelOverloadNotFoundException.java"],

common/src/main/java/dev/cel/common/exceptions/CelDuplicateKeyException.java

@@ -0,0 +1,31 @@
+// Copyright 2026 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package dev.cel.common.exceptions;
+
+import dev.cel.common.CelErrorCode;
+import dev.cel.common.annotations.Internal;
+
+/** Indicates an attempt to create a map using duplicate keys. */
+@Internal
+public final class CelDuplicateKeyException extends CelRuntimeException {
+
+  public static CelDuplicateKeyException of(Object key) {
+    return new CelDuplicateKeyException(String.format("duplicate map key [%s]", key));
+  }
+
+  private CelDuplicateKeyException(String message) {
+    super(message, CelErrorCode.DUPLICATE_ATTRIBUTE);
+  }
+}

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

@@ -63,8 +63,8 @@ java_library(
     deps = [
         ":error_metadata",
         ":execution_frame",
+        ":localized_evaluation_exception",
         ":planned_interpretable",
-        ":strict_error_exception",
         "//:auto_value",
         "//common:options",
         "//common/exceptions:runtime_exception",
@@ -87,8 +87,6 @@ java_library(
     deps = [
         ":execution_frame",
         ":planned_interpretable",
-        "//common/values",
-        "//common/values:cel_byte_string",
         "//runtime:interpretable",
         "@maven//:com_google_errorprone_error_prone_annotations",
         "@maven//:com_google_guava_guava",
@@ -321,7 +319,9 @@ java_library(
     srcs = ["EvalCreateMap.java"],
     deps = [
         ":execution_frame",
+        ":localized_evaluation_exception",
         ":planned_interpretable",
+        "//common/exceptions:duplicate_key",
         "//runtime:evaluation_exception",
         "//runtime:interpretable",
         "@maven//:com_google_errorprone_error_prone_annotations",
@@ -361,8 +361,8 @@ java_library(
     srcs = ["EvalHelpers.java"],
     deps = [
         ":execution_frame",
+        ":localized_evaluation_exception",
         ":planned_interpretable",
-        ":strict_error_exception",
         "//common:error_codes",
         "//common/exceptions:runtime_exception",
         "//common/values",
@@ -371,8 +371,8 @@ java_library(
 )
 
 java_library(
-    name = "strict_error_exception",
-    srcs = ["StrictErrorException.java"],
+    name = "localized_evaluation_exception",
+    srcs = ["LocalizedEvaluationException.java"],
     deps = [
         "//common:error_codes",
         "//common/exceptions:runtime_exception",

runtime/src/main/java/dev/cel/runtime/planner/EvalConstant.java

@@ -14,26 +14,12 @@
 
 package dev.cel.runtime.planner;
 
-import com.google.common.primitives.UnsignedLong;
 import com.google.errorprone.annotations.Immutable;
-import dev.cel.common.values.CelByteString;
-import dev.cel.common.values.NullValue;
 import dev.cel.runtime.GlobalResolver;
 
 @Immutable
 final class EvalConstant extends PlannedInterpretable {
 
-  // Pre-allocation of common constants
-  private static final EvalConstant NULL_VALUE = new EvalConstant(NullValue.NULL_VALUE);
-  private static final EvalConstant TRUE = new EvalConstant(true);
-  private static final EvalConstant FALSE = new EvalConstant(false);
-  private static final EvalConstant ZERO = new EvalConstant(0L);
-  private static final EvalConstant ONE = new EvalConstant(1L);
-  private static final EvalConstant UNSIGNED_ZERO = new EvalConstant(UnsignedLong.ZERO);
-  private static final EvalConstant UNSIGNED_ONE = new EvalConstant(UnsignedLong.ONE);
-  private static final EvalConstant EMPTY_STRING = new EvalConstant("");
-  private static final EvalConstant EMPTY_BYTES = new EvalConstant(CelByteString.EMPTY);
-
   @SuppressWarnings("Immutable") // Known CEL constants that aren't mutated are stored
   private final Object constant;
 
@@ -42,59 +28,12 @@ public Object eval(GlobalResolver resolver, ExecutionFrame frame) {
     return constant;
   }
 
-  static EvalConstant create(boolean value) {
-    return value ? TRUE : FALSE;
-  }
-
-  static EvalConstant create(String value) {
-    if (value.isEmpty()) {
-      return EMPTY_STRING;
-    }
-
-    return new EvalConstant(value);
-  }
-
-  static EvalConstant create(long value) {
-    if (value == 0L) {
-      return ZERO;
-    } else if (value == 1L) {
-      return ONE;
-    }
-
-    return new EvalConstant(Long.valueOf(value));
-  }
-
-  static EvalConstant create(double value) {
-    return new EvalConstant(Double.valueOf(value));
-  }
-
-  static EvalConstant create(UnsignedLong unsignedLong) {
-    if (unsignedLong.longValue() == 0L) {
-      return UNSIGNED_ZERO;
-    } else if (unsignedLong.longValue() == 1L) {
-      return UNSIGNED_ONE;
-    }
-
-    return new EvalConstant(unsignedLong);
-  }
-
-  static EvalConstant create(NullValue unused) {
-    return NULL_VALUE;
-  }
-
-  static EvalConstant create(CelByteString byteString) {
-    if (byteString.isEmpty()) {
-      return EMPTY_BYTES;
-    }
-    return new EvalConstant(byteString);
-  }
-
-  static EvalConstant create(Object value) {
-    return new EvalConstant(value);
+  static EvalConstant create(long exprId, Object value) {
+    return new EvalConstant(exprId, value);
   }
 
-  private EvalConstant(Object constant) {
-    super(/* exprId= */ -1); // It's not possible to throw while evaluating a constant
+  private EvalConstant(long exprId, Object constant) {
+    super(exprId);
     this.constant = constant;
   }
 }

runtime/src/main/java/dev/cel/runtime/planner/EvalCreateMap.java

@@ -16,9 +16,12 @@
 
 import com.google.common.base.Preconditions;
 import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.Sets;
 import com.google.errorprone.annotations.Immutable;
+import dev.cel.common.exceptions.CelDuplicateKeyException;
 import dev.cel.runtime.CelEvaluationException;
 import dev.cel.runtime.GlobalResolver;
+import java.util.HashSet;
 
 @Immutable
 final class EvalCreateMap extends PlannedInterpretable {
@@ -35,13 +38,23 @@ final class EvalCreateMap extends PlannedInterpretable {
   public Object eval(GlobalResolver resolver, ExecutionFrame frame) throws CelEvaluationException {
     ImmutableMap.Builder<Object, Object> builder =
         ImmutableMap.builderWithExpectedSize(keys.length);
+    HashSet<Object> keysSeen = Sets.newHashSetWithExpectedSize(keys.length);
+
     for (int i = 0; i < keys.length; i++) {
-      builder.put(keys[i].eval(resolver, frame), values[i].eval(resolver, frame));
+      Object key = keys[i].eval(resolver, frame);
+
+      if (!keysSeen.add(key)) {
+        throw new LocalizedEvaluationException(CelDuplicateKeyException.of(key), keys[i].exprId());
+      }
+
+      builder.put(key, values[i].eval(resolver, frame));
     }
+
     return builder.buildOrThrow();
   }
 
-  static EvalCreateMap create(long exprId, PlannedInterpretable[] keys, PlannedInterpretable[] values) {
+  static EvalCreateMap create(
+      long exprId, PlannedInterpretable[] keys, PlannedInterpretable[] values) {
     return new EvalCreateMap(exprId, keys, values);
   }
 

runtime/src/main/java/dev/cel/runtime/planner/EvalHelpers.java

@@ -25,8 +25,8 @@ static Object evalNonstrictly(
       PlannedInterpretable interpretable, GlobalResolver resolver, ExecutionFrame frame) {
     try {
       return interpretable.eval(resolver, frame);
-    } catch (StrictErrorException e) {
-      // Intercept the strict exception to get a more localized expr ID for error reporting purposes
+    } catch (LocalizedEvaluationException e) {
+      // Intercept the localized exception to get a more specific expr ID for error reporting
       // Example: foo [1] && strict_err [2] -> ID 2 is propagated.
       return ErrorValue.create(e.exprId(), e);
     } catch (Exception e) {
@@ -39,9 +39,11 @@ static Object evalStrictly(
     try {
       return interpretable.eval(resolver, frame);
     } catch (CelRuntimeException e) {
-      throw new StrictErrorException(e, interpretable.exprId());
+      // Wrap with current interpretable's location
+      throw new LocalizedEvaluationException(e, interpretable.exprId());
     } catch (Exception e) {
-      throw new StrictErrorException(
+      // Wrap generic exceptions with location
+      throw new LocalizedEvaluationException(
           e.getCause(), CelErrorCode.INTERNAL_ERROR, interpretable.exprId());
     }
   }

…untime/planner/StrictErrorException.java …lanner/LocalizedEvaluationException.javaruntime/src/main/java/dev/cel/runtime/planner/StrictErrorException.java renamed to runtime/src/main/java/dev/cel/runtime/planner/LocalizedEvaluationException.java runtime/src/main/java/dev/cel/runtime/planner/StrictErrorException.java renamed to runtime/src/main/java/dev/cel/runtime/planner/LocalizedEvaluationException.java

@@ -1,4 +1,4 @@
-// Copyright 2025 Google LLC
+// Copyright 2026 Google LLC
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -18,24 +18,28 @@
 import dev.cel.common.exceptions.CelRuntimeException;
 
 /**
- * An exception that's raised when a strict call failed to invoke, which includes the source of
- * expression ID, along with canonical CelErrorCode.
+ * Wraps a {@link CelRuntimeException} with its source expression ID for error reporting.
  *
- * <p>Note that StrictErrorException should not be surfaced directly back to the user.
+ * <p>This is the ONLY exception type that propagates through evaluation in the planner. All
+ * CelRuntimeExceptions from runtime helpers are immediately wrapped with location information to
+ * track where the error occurred in the expression tree.
+ *
+ * <p>Note: This exception should not be surfaced directly to users - it's unwrapped in {@link
+ * PlannedProgram}.
  */
-final class StrictErrorException extends CelRuntimeException {
+final class LocalizedEvaluationException extends CelRuntimeException {
 
   private final long exprId;
 
   long exprId() {
     return exprId;
   }
 
-  StrictErrorException(CelRuntimeException cause, long exprId) {
+  LocalizedEvaluationException(CelRuntimeException cause, long exprId) {
     this(cause, cause.getErrorCode(), exprId);
   }
 
-  StrictErrorException(Throwable cause, CelErrorCode errorCode, long exprId) {
+  LocalizedEvaluationException(Throwable cause, CelErrorCode errorCode, long exprId) {
     super(cause, errorCode);
     this.exprId = exprId;
   }

runtime/src/main/java/dev/cel/runtime/planner/PlannedProgram.java

@@ -106,9 +106,12 @@ private Object evalOrThrow(
 
   private CelEvaluationException newCelEvaluationException(long exprId, Exception e) {
     CelEvaluationExceptionBuilder builder;
-    if (e instanceof StrictErrorException) {
-      // Preserve detailed error, including error codes if one exists.
-      builder = CelEvaluationExceptionBuilder.newBuilder((CelRuntimeException) e.getCause());
+    if (e instanceof LocalizedEvaluationException) {
+      // Use the localized expr ID (most specific error location)
+      LocalizedEvaluationException localized = (LocalizedEvaluationException) e;
+      exprId = localized.exprId();
+      builder =
+          CelEvaluationExceptionBuilder.newBuilder((CelRuntimeException) localized.getCause());
     } else if (e instanceof CelRuntimeException) {
       builder = CelEvaluationExceptionBuilder.newBuilder((CelRuntimeException) e);
     } else {

runtime/src/main/java/dev/cel/runtime/planner/ProgramPlanner.java

@@ -91,7 +91,7 @@ public Program plan(CelAbstractSyntaxTree ast) throws CelEvaluationException {
   private PlannedInterpretable plan(CelExpr celExpr, PlannerContext ctx) {
     switch (celExpr.getKind()) {
       case CONSTANT:
-        return planConstant(celExpr.constant());
+        return planConstant(celExpr.id(), celExpr.constant());
       case IDENT:
         return planIdent(celExpr, ctx);
       case SELECT:
@@ -134,22 +134,22 @@ private PlannedInterpretable planSelect(CelExpr celExpr, PlannerContext ctx) {
     return attribute.addQualifier(celExpr.id(), qualifier);
   }
 
-  private PlannedInterpretable planConstant(CelConstant celConstant) {
+  private PlannedInterpretable planConstant(long exprId, CelConstant celConstant) {
     switch (celConstant.getKind()) {
       case NULL_VALUE:
-        return EvalConstant.create(celConstant.nullValue());
+        return EvalConstant.create(exprId, celConstant.nullValue());
       case BOOLEAN_VALUE:
-        return EvalConstant.create(celConstant.booleanValue());
+        return EvalConstant.create(exprId, celConstant.booleanValue());
       case INT64_VALUE:
-        return EvalConstant.create(celConstant.int64Value());
+        return EvalConstant.create(exprId, celConstant.int64Value());
       case UINT64_VALUE:
-        return EvalConstant.create(celConstant.uint64Value());
+        return EvalConstant.create(exprId, celConstant.uint64Value());
       case DOUBLE_VALUE:
-        return EvalConstant.create(celConstant.doubleValue());
+        return EvalConstant.create(exprId, celConstant.doubleValue());
       case STRING_VALUE:
-        return EvalConstant.create(celConstant.stringValue());
+        return EvalConstant.create(exprId, celConstant.stringValue());
       case BYTES_VALUE:
-        return EvalConstant.create(celConstant.bytesValue());
+        return EvalConstant.create(exprId, celConstant.bytesValue());
       default:
         throw new IllegalStateException("Unsupported kind: " + celConstant.getKind());
     }
@@ -168,7 +168,7 @@ private PlannedInterpretable planIdent(CelExpr celExpr, PlannerContext ctx) {
   private PlannedInterpretable planCheckedIdent(
       long id, CelReference identRef, ImmutableMap<Long, CelType> typeMap) {
     if (identRef.value().isPresent()) {
-      return planConstant(identRef.value().get());
+      return planConstant(id, identRef.value().get());
     }
 
     CelType type = typeMap.get(id);
@@ -181,7 +181,7 @@ private PlannedInterpretable planCheckedIdent(
                   () ->
                       new NoSuchElementException(
                           "Reference to an undefined type: " + identRef.name()));
-      return EvalConstant.create(identType);
+      return EvalConstant.create(id, identType);
     }
 
     return EvalAttribute.create(id, attributeFactory.newAbsoluteAttribute(identRef.name()));