Change function failures (dispatch / overload match) to always include the function name

PiperOrigin-RevId: 904088792

Author: l46kok

extensions/src/test/java/dev/cel/extensions/CelListsExtensionsTest.java

@@ -29,6 +29,7 @@
 import dev.cel.expr.conformance.test.SimpleTest;
 import dev.cel.parser.CelStandardMacro;
 import dev.cel.runtime.CelEvaluationException;
+import dev.cel.testing.CelRuntimeFlavor;
 import org.junit.Assume;
 import org.junit.Test;
 import org.junit.runner.RunWith;
@@ -143,7 +144,7 @@ public void flatten_negativeDepth_throws() {
     CelEvaluationException e =
         assertThrows(CelEvaluationException.class, () -> eval(cel, "[1,2,3,4].flatten(-1)"));
 
-    if (isParseOnly) {
+    if (runtimeFlavor.equals(CelRuntimeFlavor.PLANNER)) {
       assertThat(e)
           .hasMessageThat()
           .contains("evaluation error at <input>:17: Function 'flatten' failed");

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

@@ -53,6 +53,7 @@ LITE_PROGRAM_IMPL_SOURCES = [
 FUNCTION_BINDING_SOURCES = [
     "CelFunctionBinding.java",
     "FunctionBindingImpl.java",
+    "InternalCelFunctionBinding.java",
 ]
 
 # keep sorted
@@ -740,6 +741,7 @@ java_library(
     deps = [
         ":evaluation_exception",
         ":function_overload",
+        "//common/annotations",
         "//common/exceptions:overload_not_found",
         "@maven//:com_google_errorprone_error_prone_annotations",
         "@maven//:com_google_guava_guava",
@@ -754,6 +756,7 @@ cel_android_library(
     deps = [
         ":evaluation_exception",
         ":function_overload_android",
+        "//common/annotations",
         "//common/exceptions:overload_not_found",
         "@maven//:com_google_errorprone_error_prone_annotations",
         "@maven_android//:com_google_guava_guava",
@@ -890,7 +893,6 @@ java_library(
         "//common/types:type_providers",
         "//common/values:cel_value_provider",
         "//common/values:proto_message_value_provider",
-        "//runtime/standard:add",
         "//runtime/standard:int",
         "//runtime/standard:timestamp",
         "@maven//:com_google_code_findbugs_annotations",

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

@@ -100,6 +100,7 @@ static CelFunctionBinding from(
         overloadId, ImmutableList.copyOf(argTypes), impl, /* isStrict= */ true);
   }
 
+
   /** See {@link #fromOverloads(String, Collection)}. */
   static ImmutableSet<CelFunctionBinding> fromOverloads(
       String functionName, CelFunctionBinding... overloadBindings) {

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

@@ -63,7 +63,12 @@ public static CelLateFunctionBindings from(Collection<CelFunctionBinding> functi
   }
 
   private static CelResolvedOverload createResolvedOverload(CelFunctionBinding binding) {
+    String functionName = binding.getOverloadId();
+    if (binding instanceof InternalCelFunctionBinding) {
+      functionName = ((InternalCelFunctionBinding) binding).getFunctionName();
+    }
     return CelResolvedOverload.of(
+        functionName,
         binding.getOverloadId(),
         binding.getDefinition(),
         binding.isStrict(),

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

@@ -30,6 +30,9 @@
 @Internal
 public abstract class CelResolvedOverload {
 
+  /** The base function name. */
+  public abstract String getFunctionName();
+
   /** The overload id of the function. */
   public abstract String getOverloadId();
 
@@ -61,40 +64,44 @@ public Object invoke(Object[] args) throws CelEvaluationException {
         || CelFunctionOverload.canHandle(args, getParameterTypes(), isStrict())) {
       return getDefinition().apply(args);
     }
-    throw new CelOverloadNotFoundException(getOverloadId());
+    throw new CelOverloadNotFoundException(getFunctionName(), ImmutableList.of(getOverloadId()));
   }
 
   public Object invoke(Object arg) throws CelEvaluationException {
     if (isDynamicDispatch()
         || CelFunctionOverload.canHandle(arg, getParameterTypes(), isStrict())) {
       return getOptimizedDefinition().apply(arg);
     }
-    throw new CelOverloadNotFoundException(getOverloadId());
+    throw new CelOverloadNotFoundException(getFunctionName(), ImmutableList.of(getOverloadId()));
   }
 
   public Object invoke(Object arg1, Object arg2) throws CelEvaluationException {
     if (isDynamicDispatch()
         || CelFunctionOverload.canHandle(arg1, arg2, getParameterTypes(), isStrict())) {
       return getOptimizedDefinition().apply(arg1, arg2);
     }
-    throw new CelOverloadNotFoundException(getOverloadId());
+    throw new CelOverloadNotFoundException(getFunctionName(), ImmutableList.of(getOverloadId()));
   }
 
   /**
-   * Creates a new resolved overload from the given overload id, parameter types, and definition.
+   * Creates a new resolved overload from the given function name, overload id, parameter types, and
+   * definition.
    */
   public static CelResolvedOverload of(
+      String functionName,
       String overloadId,
       CelFunctionOverload definition,
       boolean isStrict,
       Class<?>... parameterTypes) {
-    return of(overloadId, definition, isStrict, ImmutableList.copyOf(parameterTypes));
+    return of(functionName, overloadId, definition, isStrict, ImmutableList.copyOf(parameterTypes));
   }
 
   /**
-   * Creates a new resolved overload from the given overload id, parameter types, and definition.
+   * Creates a new resolved overload from the given function name, overload id, parameter types, and
+   * definition.
    */
   public static CelResolvedOverload of(
+      String functionName,
       String overloadId,
       CelFunctionOverload definition,
       boolean isStrict,
@@ -104,7 +111,12 @@ public static CelResolvedOverload of(
             ? (OptimizedFunctionOverload) definition
             : definition::apply;
     return new AutoValue_CelResolvedOverload(
-        overloadId, ImmutableList.copyOf(parameterTypes), isStrict, definition, optimizedDef);
+        functionName,
+        overloadId,
+        ImmutableList.copyOf(parameterTypes),
+        isStrict,
+        definition,
+        optimizedDef);
   }
 
   /**

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

@@ -381,15 +381,25 @@ private static DefaultDispatcher newDispatcher(
       DefaultDispatcher.Builder builder = DefaultDispatcher.newBuilder();
       for (CelFunctionBinding binding :
           standardFunctions.newFunctionBindings(runtimeEquality, options)) {
+        String functionName = binding.getOverloadId();
+        if (binding instanceof InternalCelFunctionBinding) {
+          functionName = ((InternalCelFunctionBinding) binding).getFunctionName();
+        }
         builder.addOverload(
+            functionName,
             binding.getOverloadId(),
             binding.getArgTypes(),
             binding.isStrict(),
             binding.getDefinition());
       }
 
       for (CelFunctionBinding binding : customFunctionBindings) {
+        String functionName = binding.getOverloadId();
+        if (binding instanceof InternalCelFunctionBinding) {
+          functionName = ((InternalCelFunctionBinding) binding).getFunctionName();
+        }
         builder.addOverload(
+            functionName,
             binding.getOverloadId(),
             binding.getArgTypes(),
             binding.isStrict(),

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

@@ -305,15 +305,25 @@ public CelRuntimeLegacyImpl build() {
       DefaultDispatcher.Builder dispatcherBuilder = DefaultDispatcher.newBuilder();
       for (CelFunctionBinding standardFunctionBinding :
           newStandardFunctionBindings(runtimeEquality)) {
+        String functionName = standardFunctionBinding.getOverloadId();
+        if (standardFunctionBinding instanceof InternalCelFunctionBinding) {
+          functionName = ((InternalCelFunctionBinding) standardFunctionBinding).getFunctionName();
+        }
         dispatcherBuilder.addOverload(
+            functionName,
             standardFunctionBinding.getOverloadId(),
             standardFunctionBinding.getArgTypes(),
             standardFunctionBinding.isStrict(),
             standardFunctionBinding.getDefinition());
       }
 
       for (CelFunctionBinding customBinding : customFunctionBindings.values()) {
+        String functionName = customBinding.getOverloadId();
+        if (customBinding instanceof InternalCelFunctionBinding) {
+          functionName = ((InternalCelFunctionBinding) customBinding).getFunctionName();
+        }
         dispatcherBuilder.addOverload(
+            functionName,
             customBinding.getOverloadId(),
             customBinding.getArgTypes(),
             customBinding.isStrict(),

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

@@ -134,32 +134,41 @@ public static class Builder {
     @AutoValue
     @Immutable
     abstract static class OverloadEntry {
+      abstract String functionName();
+
       abstract ImmutableList<Class<?>> argTypes();
 
       abstract boolean isStrict();
 
       abstract CelFunctionOverload overload();
 
       private static OverloadEntry of(
-          ImmutableList<Class<?>> argTypes, boolean isStrict, CelFunctionOverload overload) {
-        return new AutoValue_DefaultDispatcher_Builder_OverloadEntry(argTypes, isStrict, overload);
+          String functionName,
+          ImmutableList<Class<?>> argTypes,
+          boolean isStrict,
+          CelFunctionOverload overload) {
+        return new AutoValue_DefaultDispatcher_Builder_OverloadEntry(
+            functionName, argTypes, isStrict, overload);
       }
     }
 
     private final Map<String, OverloadEntry> overloads;
 
     @CanIgnoreReturnValue
     public Builder addOverload(
+        String functionName,
         String overloadId,
         ImmutableList<Class<?>> argTypes,
         boolean isStrict,
         CelFunctionOverload overload) {
+      checkNotNull(functionName);
+      checkArgument(!functionName.isEmpty(), "Function name cannot be empty.");
       checkNotNull(overloadId);
       checkArgument(!overloadId.isEmpty(), "Overload ID cannot be empty.");
       checkNotNull(argTypes);
       checkNotNull(overload);
 
-      OverloadEntry newEntry = OverloadEntry.of(argTypes, isStrict, overload);
+      OverloadEntry newEntry = OverloadEntry.of(functionName, argTypes, isStrict, overload);
 
       overloads.merge(
           overloadId,
@@ -188,7 +197,7 @@ private OverloadEntry mergeDynamicDispatchesOrThrow(
         boolean isStrict =
             mergedOverload.getOverloadBindings().stream().allMatch(CelFunctionBinding::isStrict);
 
-        return OverloadEntry.of(incoming.argTypes(), isStrict, mergedOverload);
+        return OverloadEntry.of(overloadId, incoming.argTypes(), isStrict, mergedOverload);
       }
 
       throw new IllegalArgumentException("Duplicate overload ID binding: " + overloadId);
@@ -204,7 +213,11 @@ public DefaultDispatcher build() {
         resolvedOverloads.put(
             overloadId,
             CelResolvedOverload.of(
-                overloadId, overloadImpl, overloadEntry.isStrict(), overloadEntry.argTypes()));
+                overloadEntry.functionName(),
+                overloadId,
+                overloadImpl,
+                overloadEntry.isStrict(),
+                overloadEntry.argTypes()));
       }
 
       return new DefaultDispatcher(resolvedOverloads.buildOrThrow());

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

@@ -23,7 +23,9 @@
 import dev.cel.common.exceptions.CelOverloadNotFoundException;
 
 @Immutable
-final class FunctionBindingImpl implements CelFunctionBinding {
+final class FunctionBindingImpl implements InternalCelFunctionBinding {
+
+  private final String functionName;
 
   private final String overloadId;
 
@@ -33,6 +35,11 @@ final class FunctionBindingImpl implements CelFunctionBinding {
 
   private final boolean isStrict;
 
+  @Override
+  public String getFunctionName() {
+    return functionName;
+  }
+
   @Override
   public String getOverloadId() {
     return overloadId;
@@ -54,20 +61,34 @@ public boolean isStrict() {
   }
 
   FunctionBindingImpl(
+      String functionName,
       String overloadId,
       ImmutableList<Class<?>> argTypes,
       CelFunctionOverload definition,
       boolean isStrict) {
+    this.functionName = functionName;
     this.overloadId = overloadId;
     this.argTypes = argTypes;
     this.definition = definition;
     this.isStrict = isStrict;
   }
 
+  FunctionBindingImpl(
+      String overloadId,
+      ImmutableList<Class<?>> argTypes,
+      CelFunctionOverload definition,
+      boolean isStrict) {
+    this(overloadId, overloadId, argTypes, definition, isStrict);
+  }
+
   static ImmutableSet<CelFunctionBinding> groupOverloadsToFunction(
       String functionName, ImmutableSet<CelFunctionBinding> overloadBindings) {
     ImmutableSet.Builder<CelFunctionBinding> builder = ImmutableSet.builder();
-    builder.addAll(overloadBindings);
+    for (CelFunctionBinding b : overloadBindings) {
+      builder.add(
+          new FunctionBindingImpl(
+              functionName, b.getOverloadId(), b.getArgTypes(), b.getDefinition(), b.isStrict()));
+    }
 
     // If there is already a binding with the same name as the function, we treat it as a
     // "Singleton" binding and do not create a dynamic dispatch wrapper for it.
@@ -80,11 +101,12 @@ static ImmutableSet<CelFunctionBinding> groupOverloadsToFunction(
         CelFunctionBinding singleBinding = Iterables.getOnlyElement(overloadBindings);
         builder.add(
             new FunctionBindingImpl(
+                functionName,
                 functionName,
                 singleBinding.getArgTypes(),
                 singleBinding.getDefinition(),
                 singleBinding.isStrict()));
-      } else {
+      } else if (overloadBindings.size() > 1) {
         builder.add(new DynamicDispatchBinding(functionName, overloadBindings));
       }
     }
@@ -93,7 +115,7 @@ static ImmutableSet<CelFunctionBinding> groupOverloadsToFunction(
   }
 
   @Immutable
-  static final class DynamicDispatchBinding implements CelFunctionBinding {
+  static final class DynamicDispatchBinding implements InternalCelFunctionBinding {
 
     private final boolean isStrict;
     private final DynamicDispatchOverload dynamicDispatchOverload;
@@ -103,6 +125,11 @@ public String getOverloadId() {
       return dynamicDispatchOverload.functionName;
     }
 
+    @Override
+    public String getFunctionName() {
+      return dynamicDispatchOverload.functionName;
+    }
+
     @Override
     public ImmutableList<Class<?>> getArgTypes() {
       return ImmutableList.of();

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

@@ -0,0 +1,29 @@
+// 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.runtime;
+
+import com.google.errorprone.annotations.Immutable;
+import dev.cel.common.annotations.Internal;
+
+/**
+ * Internal interface to expose the function name associated with a binding.
+ *
+ * <p>CEL Library Internals. Do Not Use.
+ */
+@Internal
+@Immutable
+public interface InternalCelFunctionBinding extends CelFunctionBinding {
+  String getFunctionName();
+}