From 0c12c040257e3b4907388048241934503630570d Mon Sep 17 00:00:00 2001 From: Sean Huh Date: Thu, 19 Nov 2026 17:21:33 -0800 Subject: [PATCH] Merges function bindings registered under the same function name across multiple runtime libraries or binding calls. For example, when both the lists and strings extensions are enabled, `dyn('hello').reverse()` and parsed-only `'hello'.reverse()` previously failed with no matching overload and now evaluate to `'olleh'`. PiperOrigin-RevId: 1026027796 --- .../dev/cel/extensions/CelExtensionsTest.java | 108 +++++++++++++++++- .../dev/cel/runtime/CelLiteRuntimeImpl.java | 3 +- .../java/dev/cel/runtime/CelRuntimeImpl.java | 15 ++- .../dev/cel/runtime/FunctionBindingImpl.java | 31 ++--- .../cel/runtime/FunctionBindingImplTest.java | 31 +++++ 5 files changed, 168 insertions(+), 20 deletions(-) diff --git a/extensions/src/test/java/dev/cel/extensions/CelExtensionsTest.java b/extensions/src/test/java/dev/cel/extensions/CelExtensionsTest.java index 06a6ba142..ab87a86c9 100644 --- a/extensions/src/test/java/dev/cel/extensions/CelExtensionsTest.java +++ b/extensions/src/test/java/dev/cel/extensions/CelExtensionsTest.java @@ -15,20 +15,32 @@ package dev.cel.extensions; import static com.google.common.truth.Truth.assertThat; +import static dev.cel.common.CelFunctionDecl.newFunctionDeclaration; +import static dev.cel.common.CelOverloadDecl.newGlobalOverload; import static org.junit.Assert.assertThrows; +import com.google.testing.junit.testparameterinjector.TestParameter; +import com.google.testing.junit.testparameterinjector.TestParameterInjector; import dev.cel.bundle.Cel; import dev.cel.bundle.CelFactory; import dev.cel.common.CelAbstractSyntaxTree; import dev.cel.common.CelOptions; import dev.cel.common.CelValidationException; +import dev.cel.common.types.SimpleType; +import dev.cel.compiler.CelCompiler; +import dev.cel.compiler.CelCompilerFactory; import dev.cel.extensions.CelStringExtensions.Function; import dev.cel.runtime.CelEvaluationException; +import dev.cel.runtime.CelFunctionBinding; +import dev.cel.runtime.CelLiteRuntime; +import dev.cel.runtime.CelLiteRuntimeFactory; +import dev.cel.runtime.CelRuntime; +import dev.cel.runtime.CelStandardFunctions; +import java.util.Optional; import org.junit.Test; import org.junit.runner.RunWith; -import org.junit.runners.JUnit4; -@RunWith(JUnit4.class) +@RunWith(TestParameterInjector.class) public class CelExtensionsTest { @Test @@ -197,4 +209,96 @@ public void getAllFunctionNames() { "optional.ofNonZeroValue", "cel.@mapInsert"); } + + @Test + public void crossExtensionSharedFunctionName_reverse_dispatchesAcrossListsAndStrings( + @TestParameter boolean isParseOnly) throws Exception { + Cel cel = + CelFactory.plannerCelBuilder() + .addCompilerLibraries(CelExtensions.lists(), CelExtensions.strings()) + .addRuntimeLibraries(CelExtensions.lists(), CelExtensions.strings()) + .build(); + String expression = "dyn('hello').reverse() == 'olleh' && dyn([1, 2]).reverse() == [2, 1]"; + CelAbstractSyntaxTree ast = + isParseOnly ? cel.parse(expression).getAst() : cel.compile(expression).getAst(); + + Object result = cel.createProgram(ast).eval(); + + assertThat(result).isEqualTo(true); + } + + @Test + public void crossExtensionSharedFunctionName_liteRuntime_reverseDispatchesAcrossListsAndStrings( + @TestParameter boolean isParseOnly) throws Exception { + CelCompiler compiler = + CelCompilerFactory.standardCelCompilerBuilder() + .addLibraries(CelExtensions.lists(), CelExtensions.strings()) + .build(); + CelLiteRuntime runtime = + CelLiteRuntimeFactory.newLiteRuntimeBuilder() + .setStandardFunctions(CelStandardFunctions.ALL_STANDARD_FUNCTIONS) + .addLibraries(CelListsRuntimeLibrary.lists(), CelStringRuntimeLibrary.strings()) + .build(); + String expression = "dyn('hello').reverse() == 'olleh' && dyn([1, 2]).reverse() == [2, 1]"; + CelAbstractSyntaxTree ast = + isParseOnly ? compiler.parse(expression).getAst() : compiler.compile(expression).getAst(); + + Object result = runtime.createProgram(ast).eval(); + + assertThat(result).isEqualTo(true); + } + + @Test + public void toCelBuilder_mergesDerivedLibrariesAndFunctionBindings() throws Exception { + Cel baseCel = + CelFactory.plannerCelBuilder() + .addCompilerLibraries(CelExtensions.lists()) + .addRuntimeLibraries(CelExtensions.lists()) + .addFunctionDeclarations( + newFunctionDeclaration( + "fn", + newGlobalOverload("fn_int", SimpleType.INT, SimpleType.INT), + newGlobalOverload("fn_str", SimpleType.STRING, SimpleType.STRING))) + .addFunctionBindings( + CelFunctionBinding.fromOverloads( + "fn", CelFunctionBinding.from("fn_int", Long.class, x -> x + 1L))) + .build(); + Cel derivedCel = + baseCel + .toCelBuilder() + .addCompilerLibraries(CelExtensions.strings()) + .addRuntimeLibraries(CelExtensions.strings()) + .addFunctionBindings( + CelFunctionBinding.fromOverloads( + "fn", + CelFunctionBinding.from("fn_int", Long.class, x -> x + 100L), + CelFunctionBinding.from("fn_str", String.class, s -> s + "!"))) + .build(); + String expression = + "dyn('hello').reverse() == 'olleh' && dyn([1, 2]).reverse() == [2, 1]" + + " && fn(dyn(1)) == 2 && fn(dyn('a')) == 'a!'"; + + assertThat(derivedCel.createProgram(derivedCel.compile(expression).getAst()).eval()) + .isEqualTo(true); + assertThat(derivedCel.createProgram(derivedCel.parse(expression).getAst()).eval()) + .isEqualTo(true); + } + + @Test + public void toRuntimeBuilder_optionalLibrary_updatesRuntimeEquality() throws Exception { + Cel defaultCel = + CelFactory.plannerCelBuilder() + .addCompilerLibraries(CelExtensions.optional()) + .addRuntimeLibraries(CelExtensions.optional()) + .build(); + CelAbstractSyntaxTree ast = defaultCel.compile("{1: 'a'}[?dyn(1.0)]").getAst(); + CelRuntime strictMapKeyRuntime = + defaultCel + .toRuntimeBuilder() + .setOptions(CelOptions.current().disableCelStandardEquality(true).build()) + .build(); + + assertThat(defaultCel.createProgram(ast).eval()).isEqualTo(Optional.of("a")); + assertThat(strictMapKeyRuntime.createProgram(ast).eval()).isEqualTo(Optional.empty()); + } } diff --git a/runtime/src/main/java/dev/cel/runtime/CelLiteRuntimeImpl.java b/runtime/src/main/java/dev/cel/runtime/CelLiteRuntimeImpl.java index 00eb6dcfd..87e3e40cc 100644 --- a/runtime/src/main/java/dev/cel/runtime/CelLiteRuntimeImpl.java +++ b/runtime/src/main/java/dev/cel/runtime/CelLiteRuntimeImpl.java @@ -115,7 +115,8 @@ public CelLiteRuntimeBuilder addFunctionBindings(CelFunctionBinding... bindings) @Override public CelLiteRuntimeBuilder addFunctionBindings(Iterable bindings) { - bindings.forEach(o -> customFunctionBindings.putIfAbsent(o.getOverloadId(), o)); + bindings.forEach( + o -> customFunctionBindings.merge(o.getOverloadId(), o, FunctionBindingImpl::merge)); return this; } diff --git a/runtime/src/main/java/dev/cel/runtime/CelRuntimeImpl.java b/runtime/src/main/java/dev/cel/runtime/CelRuntimeImpl.java index e2da9de05..987e3c265 100644 --- a/runtime/src/main/java/dev/cel/runtime/CelRuntimeImpl.java +++ b/runtime/src/main/java/dev/cel/runtime/CelRuntimeImpl.java @@ -350,7 +350,8 @@ public Builder addFunctionBindings(CelFunctionBinding... bindings) { @CanIgnoreReturnValue public Builder addFunctionBindings(Iterable bindings) { checkNotNull(bindings); - bindings.forEach(o -> mutableFunctionBindings.putIfAbsent(o.getOverloadId(), o)); + bindings.forEach( + o -> mutableFunctionBindings.merge(o.getOverloadId(), o, FunctionBindingImpl::merge)); return this; } @@ -517,6 +518,14 @@ public CelRuntime build() { CelValueProvider protoMessageValueProvider = ProtoMessageValueProvider.newInstance(options(), dynamicProto); RuntimeEquality runtimeEquality = ProtoMessageRuntimeEquality.create(dynamicProto, options()); + functionBindings() + .forEach((overloadId, baseBinding) -> + mutableFunctionBindings.merge( + overloadId, + baseBinding, + (newBinding, oldBinding) -> FunctionBindingImpl.merge(oldBinding, newBinding))); + ImmutableMap userFunctionBindings = + ImmutableMap.copyOf(mutableFunctionBindings); ImmutableSet runtimeLibraries = runtimeLibrariesBuilder().build(); // Add libraries, such as extensions for (CelRuntimeLibrary celLibrary : runtimeLibraries) { @@ -549,8 +558,6 @@ public CelRuntime build() { new CelTypeProvider.CombinedCelTypeProvider(combinedTypeProvider, typeProvider()); } - mutableFunctionBindings.putAll(functionBindings()); - for (CelFunctionBinding binding : TypeFunction.create() .newFunctionBindings( @@ -576,7 +583,7 @@ public CelRuntime build() { asyncExecutor().orElse(null)); setPlanner(planner); - setFunctionBindings(ImmutableMap.copyOf(mutableFunctionBindings)); + setFunctionBindings(userFunctionBindings); return autoBuild(); } } diff --git a/runtime/src/main/java/dev/cel/runtime/FunctionBindingImpl.java b/runtime/src/main/java/dev/cel/runtime/FunctionBindingImpl.java index 806b9d7dd..c07ba8744 100644 --- a/runtime/src/main/java/dev/cel/runtime/FunctionBindingImpl.java +++ b/runtime/src/main/java/dev/cel/runtime/FunctionBindingImpl.java @@ -18,9 +18,10 @@ import com.google.common.collect.ImmutableList; import com.google.common.collect.ImmutableSet; -import com.google.common.collect.Iterables; import com.google.errorprone.annotations.Immutable; import dev.cel.common.exceptions.CelOverloadNotFoundException; +import java.util.LinkedHashMap; +import java.util.Map; @Immutable final class FunctionBindingImpl implements InternalCelFunctionBinding { @@ -107,23 +108,27 @@ static ImmutableSet groupOverloadsToFunction( overloadBindings.stream().anyMatch(b -> b.getOverloadId().equals(functionName)); if (!hasSingletonBinding) { - if (overloadBindings.size() == 1) { - CelFunctionBinding singleBinding = Iterables.getOnlyElement(overloadBindings); - builder.add( - new FunctionBindingImpl( - functionName, - functionName, - singleBinding.getArgTypes(), - singleBinding.getDefinition(), - singleBinding.isStrict())); - } else if (overloadBindings.size() > 1) { - builder.add(new DynamicDispatchBinding(functionName, functionBindings)); - } + builder.add(new DynamicDispatchBinding(functionName, functionBindings)); } return builder.build(); } + static CelFunctionBinding merge(CelFunctionBinding existing, CelFunctionBinding incoming) { + if (existing instanceof DynamicDispatchBinding && incoming instanceof DynamicDispatchBinding) { + DynamicDispatchOverload existingOverload = + ((DynamicDispatchBinding) existing).dynamicDispatchOverload; + DynamicDispatchOverload incomingOverload = + ((DynamicDispatchBinding) incoming).dynamicDispatchOverload; + Map merged = new LinkedHashMap<>(); + existingOverload.overloadBindings.forEach(b -> merged.put(b.getOverloadId(), b)); + incomingOverload.overloadBindings.forEach(b -> merged.putIfAbsent(b.getOverloadId(), b)); + return new DynamicDispatchBinding( + existingOverload.functionName, ImmutableSet.copyOf(merged.values())); + } + return existing; + } + @Immutable static final class DynamicDispatchBinding implements InternalCelFunctionBinding { diff --git a/runtime/src/test/java/dev/cel/runtime/FunctionBindingImplTest.java b/runtime/src/test/java/dev/cel/runtime/FunctionBindingImplTest.java index 7f1a20df7..aa6ef92cb 100644 --- a/runtime/src/test/java/dev/cel/runtime/FunctionBindingImplTest.java +++ b/runtime/src/test/java/dev/cel/runtime/FunctionBindingImplTest.java @@ -364,4 +364,35 @@ public void fromOverloads_varargsAndCollection_success() { assertThat(varargsBindings).isNotEmpty(); assertThat(collectionBindings).isNotEmpty(); } + + @Test + public void merge_combinesDynamicDispatchAndDeduplicatesByOverloadId() throws Exception { + CelFunctionBinding standalone = CelFunctionBinding.from("fn", Long.class, x -> x); + CelFunctionBinding dynInt = + Iterables.find( + CelFunctionBinding.fromOverloads( + "fn", CelFunctionBinding.from("fn_int", Long.class, x -> x + 1L)), + b -> b.getOverloadId().equals("fn")); + CelFunctionBinding dynDupIntAndStr = + Iterables.find( + CelFunctionBinding.fromOverloads( + "fn", + CelFunctionBinding.from("fn_int", Long.class, x -> x + 100L), + CelFunctionBinding.from("fn_str", String.class, s -> s + "!")), + b -> b.getOverloadId().equals("fn")); + + OptimizedFunctionOverload merged = + (OptimizedFunctionOverload) + FunctionBindingImpl.merge(dynInt, dynDupIntAndStr).getDefinition(); + CelOverloadNotFoundException mismatch = + assertThrows(CelOverloadNotFoundException.class, () -> merged.apply(1.5d)); + + assertThat(merged.apply(1L)).isEqualTo(2L); + assertThat(merged.apply("hi")).isEqualTo("hi!"); + assertThat(mismatch) + .hasMessageThat() + .isEqualTo("No matching overload for function 'fn'. Overload candidates: fn_int, fn_str"); + assertThat(FunctionBindingImpl.merge(standalone, dynInt)).isSameInstanceAs(standalone); + assertThat(FunctionBindingImpl.merge(dynInt, standalone)).isSameInstanceAs(dynInt); + } }