diff --git a/extensions/src/main/java/dev/cel/extensions/BUILD.bazel b/extensions/src/main/java/dev/cel/extensions/BUILD.bazel index 3cded5e17..c952207f8 100644 --- a/extensions/src/main/java/dev/cel/extensions/BUILD.bazel +++ b/extensions/src/main/java/dev/cel/extensions/BUILD.bazel @@ -356,6 +356,7 @@ java_library( deps = [ "//common:operator", "//common:options", + "//common/exceptions:overload_not_found", "//common/values", "//common/values:cel_byte_string", "//common/values:cel_value", @@ -377,6 +378,7 @@ cel_android_library( deps = [ "//common:operator_android", "//common:options", + "//common/exceptions:overload_not_found", "//common/values:cel_byte_string", "//common/values:cel_value_android", "//common/values:values_android", diff --git a/extensions/src/main/java/dev/cel/extensions/CelOptionalRuntimeLibrary.java b/extensions/src/main/java/dev/cel/extensions/CelOptionalRuntimeLibrary.java index 68bd507b6..79d68316a 100644 --- a/extensions/src/main/java/dev/cel/extensions/CelOptionalRuntimeLibrary.java +++ b/extensions/src/main/java/dev/cel/extensions/CelOptionalRuntimeLibrary.java @@ -22,6 +22,7 @@ import com.google.protobuf.MessageLite; import dev.cel.common.CelOptions; import dev.cel.common.Operator; +import dev.cel.common.exceptions.CelOverloadNotFoundException; import dev.cel.common.values.CelByteString; import dev.cel.common.values.CelValue; import dev.cel.common.values.NullValue; @@ -223,36 +224,33 @@ public ImmutableSet newFunctionBindings(RuntimeEquality runt Operator.OPTIONAL_INDEX.getFunction(), CelFunctionBinding.from( "list_optindex_optional_int", List.class, Long.class, RuntimeHelpers::optIndexList), - CelFunctionBinding.from( - "optional_list_optindex_optional_int", - Optional.class, - Long.class, - CelOptionalRuntimeLibrary::indexOptionalList), + optionalIndexBinding( + "optional_list_optindex_optional_int", Operator.OPTIONAL_INDEX, runtimeEquality), CelFunctionBinding.from( "map_optindex_optional_value", Map.class, Object.class, runtimeEquality::findInMap), - CelFunctionBinding.from( - "optional_map_optindex_optional_value", - Optional.class, - Object.class, - (optionalMap, key) -> indexOptionalMap(optionalMap, key, runtimeEquality)))); + optionalIndexBinding( + "optional_map_optindex_optional_value", Operator.OPTIONAL_INDEX, runtimeEquality))); bindingBuilder.addAll( CelFunctionBinding.fromOverloads( Operator.INDEX.getFunction(), - CelFunctionBinding.from( - "optional_list_index_int", - Optional.class, - Long.class, - CelOptionalRuntimeLibrary::indexOptionalList), - CelFunctionBinding.from( - "optional_map_index_value", - Optional.class, - Object.class, - (optionalMap, key) -> indexOptionalMap(optionalMap, key, runtimeEquality)))); + optionalIndexBinding("optional_list_index_int", Operator.INDEX, runtimeEquality), + optionalIndexBinding("optional_map_index_value", Operator.INDEX, runtimeEquality))); return bindingBuilder.build(); } + private static CelFunctionBinding optionalIndexBinding( + String overloadId, Operator operator, RuntimeEquality runtimeEquality) { + String functionName = operator.getFunction(); + return CelFunctionBinding.from( + overloadId, + Optional.class, + Object.class, + (optionalContainer, key) -> + indexOptional(functionName, optionalContainer, key, runtimeEquality)); + } + private static ImmutableList elideOptionalCollection(Collection list) { ImmutableList.Builder builder = ImmutableList.builder(); for (Object element : list) { @@ -298,23 +296,22 @@ private static boolean isZeroValue(Object val) { return false; } - private static Object indexOptionalMap( - Optional optionalMap, Object key, RuntimeEquality runtimeEquality) { - if (!optionalMap.isPresent()) { + private static Object indexOptional( + String functionName, + Optional optionalContainer, + Object key, + RuntimeEquality runtimeEquality) { + if (!optionalContainer.isPresent()) { return Optional.empty(); } - - Map map = (Map) optionalMap.get(); - - return runtimeEquality.findInMap(map, key); - } - - private static Object indexOptionalList(Optional optionalList, long index) { - if (!optionalList.isPresent()) { - return Optional.empty(); + Object container = optionalContainer.get(); + if (container instanceof Map) { + return runtimeEquality.findInMap((Map) container, key); + } + if (container instanceof List && key instanceof Long) { + return RuntimeHelpers.optIndexList((List) container, (Long) key); } - List list = (List) optionalList.get(); - return RuntimeHelpers.optIndexList(list, index); + throw new CelOverloadNotFoundException(functionName); } private static Object listOptionalFirst(Collection list) { diff --git a/extensions/src/test/java/dev/cel/extensions/BUILD.bazel b/extensions/src/test/java/dev/cel/extensions/BUILD.bazel index 99d40146c..2e1c767f2 100644 --- a/extensions/src/test/java/dev/cel/extensions/BUILD.bazel +++ b/extensions/src/test/java/dev/cel/extensions/BUILD.bazel @@ -20,6 +20,7 @@ java_library( "//common:cel_validation_result", "//common:cel_var_decl", "//common:container", + "//common:error_codes", "//common:options", "//common/ast", "//common/exceptions:attribute_not_found", diff --git a/extensions/src/test/java/dev/cel/extensions/CelExtensionsTest.java b/extensions/src/test/java/dev/cel/extensions/CelExtensionsTest.java index ab87a86c9..6af400f45 100644 --- a/extensions/src/test/java/dev/cel/extensions/CelExtensionsTest.java +++ b/extensions/src/test/java/dev/cel/extensions/CelExtensionsTest.java @@ -212,13 +212,19 @@ public void getAllFunctionNames() { @Test public void crossExtensionSharedFunctionName_reverse_dispatchesAcrossListsAndStrings( - @TestParameter boolean isParseOnly) throws Exception { + @TestParameter({ + "dyn('hello').reverse() == 'olleh' && dyn([1, 2]).reverse() == [2, 1]", + "(([['a']] + dyn(['hello']))[1]).reverse() == dyn('olleh')", + "(('a' == '' ? 'a' : (['a'] + dyn([[1, 2]]))[1])).reverse() == dyn([2, 1])", + }) + String expression, + @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(); @@ -239,7 +245,7 @@ public void crossExtensionSharedFunctionName_liteRuntime_reverseDispatchesAcross .setStandardFunctions(CelStandardFunctions.ALL_STANDARD_FUNCTIONS) .addLibraries(CelListsRuntimeLibrary.lists(), CelStringRuntimeLibrary.strings()) .build(); - String expression = "dyn('hello').reverse() == 'olleh' && dyn([1, 2]).reverse() == [2, 1]"; + String expression = "(([['a']] + dyn(['hello']))[1]).reverse() == dyn('olleh')"; CelAbstractSyntaxTree ast = isParseOnly ? compiler.parse(expression).getAst() : compiler.compile(expression).getAst(); diff --git a/extensions/src/test/java/dev/cel/extensions/CelOptionalLibraryTest.java b/extensions/src/test/java/dev/cel/extensions/CelOptionalLibraryTest.java index daf5090de..ecd5a4d5e 100644 --- a/extensions/src/test/java/dev/cel/extensions/CelOptionalLibraryTest.java +++ b/extensions/src/test/java/dev/cel/extensions/CelOptionalLibraryTest.java @@ -33,6 +33,7 @@ import dev.cel.bundle.CelFactory; import dev.cel.common.CelAbstractSyntaxTree; import dev.cel.common.CelContainer; +import dev.cel.common.CelErrorCode; import dev.cel.common.CelFunctionDecl; import dev.cel.common.CelOptions; import dev.cel.common.CelOverloadDecl; @@ -2304,6 +2305,53 @@ public void optionalMacros_invalidExpanderArguments_throws() throws Exception { .isTrue(); } + @Test + public void optionalIndex_narrowedAndIntegerKeyedOptionalContainers_evaluatesToTrue( + @TestParameter({ + "dyn(dyn(optional.of(optional.of([2]))).orValue([1])[0]) == optional.of(2)", + "dyn(optional.of([2])).orValue({0: 1})[0] == 2", + "dyn(dyn(optional.of([2])).orValue(optional.of([1]))[0]) == 2", + "dyn(optional.of([2])).or(optional.of({0: 1}))[0] == optional.of(2)", + "dyn(dyn(optional.of(optional.of([2]))).orValue([1])[?0]) == optional.of(2)", + "optional.of({0: 2})[0] == optional.of(2)", + "optional.of({0: 2})[?0] == optional.of(2)", + "dyn(optional.of({0: 2}))[0] == optional.of(2)", + "dyn(optional.of({0: 2}))[?0] == optional.of(2)", + "dyn(dyn(optional.of(optional.of({0: 2}))).orValue([1])[0]) == optional.of(2)", + "TestAllTypes{}.?repeated_int64[dyn('a')] == optional.none()", + "TestAllTypes{}.?repeated_int64[?dyn('a')] == optional.none()", + "int(false ? timestamp(0) : (true ? dyn('42') : null)) == 42", + }) + String source) + throws Exception { + TestCel cel = newCelBuilder().build(); + Program program = cel.createProgram(compile(cel, source)); + + Object result = program.eval(); + + assertThat(result).isEqualTo(true); + } + + @Test + public void optionalIndex_invalidRuntimeContainerOrKey_throwsOverloadNotFound( + @TestParameter({ + "dyn(optional.of(42)).or(optional.of([1]))[0]", + "dyn(optional.of(42)).or(optional.of([1]))[?0]", + "dyn(optional.of([1])).or(optional.of({'a': 1}))['a']", + "dyn(optional.of([1])).or(optional.of({'a': 1}))[?'a']", + "(false ? optional.of([1]) : null)[0]", + "(false ? [1] : dyn(null))[?0]", + }) + String source) + throws Exception { + TestCel cel = newCelBuilder().build(); + Program program = cel.createProgram(compile(cel, source)); + + CelEvaluationException e = assertThrows(CelEvaluationException.class, program::eval); + + assertThat(e.getErrorCode()).isEqualTo(CelErrorCode.OVERLOAD_NOT_FOUND); + } + /** * A wrapper around {@link CelBuilder} (which uses {@link CelRuntimeBuilder}) and {@link * CelLiteRuntimeBuilder} to allow for testing of both runtimes. diff --git a/runtime/src/main/java/dev/cel/runtime/BUILD.bazel b/runtime/src/main/java/dev/cel/runtime/BUILD.bazel index 28c8d0a10..2acc5cbed 100644 --- a/runtime/src/main/java/dev/cel/runtime/BUILD.bazel +++ b/runtime/src/main/java/dev/cel/runtime/BUILD.bazel @@ -509,7 +509,6 @@ java_library( ":function_resolver", ":resolved_overload", "@maven//:com_google_errorprone_error_prone_annotations", - "@maven//:com_google_guava_guava", ], ) @@ -525,7 +524,6 @@ cel_android_library( ":function_resolver_android", ":resolved_overload_android", "@maven//:com_google_errorprone_error_prone_annotations", - "@maven_android//:com_google_guava_guava", ], ) @@ -753,6 +751,7 @@ java_library( "//common/exceptions:overload_not_found", "@maven//:com_google_errorprone_error_prone_annotations", "@maven//:com_google_guava_guava", + "@maven//:org_jspecify_jspecify", ], ) @@ -767,6 +766,7 @@ cel_android_library( "//common/annotations", "//common/exceptions:overload_not_found", "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:org_jspecify_jspecify", "@maven_android//:com_google_guava_guava", ], ) @@ -1254,6 +1254,7 @@ java_library( "//common/exceptions:overload_not_found", "@maven//:com_google_errorprone_error_prone_annotations", "@maven//:com_google_guava_guava", + "@maven//:org_jspecify_jspecify", ], ) @@ -1270,6 +1271,7 @@ cel_android_library( "//common/annotations", "//common/exceptions:overload_not_found", "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:org_jspecify_jspecify", "@maven_android//:com_google_guava_guava", ], ) diff --git a/runtime/src/main/java/dev/cel/runtime/CelLateFunctionBindings.java b/runtime/src/main/java/dev/cel/runtime/CelLateFunctionBindings.java index 2da08120c..b089c8b05 100644 --- a/runtime/src/main/java/dev/cel/runtime/CelLateFunctionBindings.java +++ b/runtime/src/main/java/dev/cel/runtime/CelLateFunctionBindings.java @@ -14,9 +14,6 @@ package dev.cel.runtime; -import static com.google.common.collect.ImmutableMap.toImmutableMap; - -import com.google.common.collect.ImmutableMap; import com.google.errorprone.annotations.Immutable; import java.util.Arrays; import java.util.Collection; @@ -29,24 +26,19 @@ @Immutable public final class CelLateFunctionBindings implements CelFunctionResolver { - private final ImmutableMap functions; - - private CelLateFunctionBindings(ImmutableMap functions) { - this.functions = functions; - } + private final DefaultDispatcher dispatcher; @Override public Optional findOverloadMatchingArgs( String functionName, Collection overloadIds, Object[] args) throws CelEvaluationException { - return DefaultDispatcher.findOverloadMatchingArgs(functionName, overloadIds, functions, args); + return dispatcher.findOverloadMatchingArgs(functionName, overloadIds, args); } @Override public Optional findOverloadMatchingArgs(String functionName, Object[] args) throws CelEvaluationException { - return DefaultDispatcher.findOverloadMatchingArgs( - functionName, functions.keySet(), functions, args); + return dispatcher.findOverloadMatchingArgs(functionName, args); } public static CelLateFunctionBindings from(CelFunctionBinding... functions) { @@ -54,24 +46,23 @@ public static CelLateFunctionBindings from(CelFunctionBinding... functions) { } public static CelLateFunctionBindings from(Collection functions) { - return new CelLateFunctionBindings( - functions.stream() - .collect( - toImmutableMap( - CelFunctionBinding::getOverloadId, - CelLateFunctionBindings::createResolvedOverload))); + DefaultDispatcher.Builder builder = DefaultDispatcher.newBuilder(); + for (CelFunctionBinding binding : functions) { + String functionName = + binding instanceof InternalCelFunctionBinding + ? ((InternalCelFunctionBinding) binding).getFunctionName() + : binding.getOverloadId(); + builder.addOverload( + functionName, + binding.getOverloadId(), + binding.getArgTypes(), + binding.isStrict(), + binding.getDefinition()); + } + return new CelLateFunctionBindings(builder.build()); } - 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(), - binding.getArgTypes()); + private CelLateFunctionBindings(DefaultDispatcher dispatcher) { + this.dispatcher = dispatcher; } } diff --git a/runtime/src/main/java/dev/cel/runtime/CelResolvedOverload.java b/runtime/src/main/java/dev/cel/runtime/CelResolvedOverload.java index 42ccdd031..174c8cade 100644 --- a/runtime/src/main/java/dev/cel/runtime/CelResolvedOverload.java +++ b/runtime/src/main/java/dev/cel/runtime/CelResolvedOverload.java @@ -19,7 +19,9 @@ import com.google.errorprone.annotations.Immutable; import dev.cel.common.annotations.Internal; import dev.cel.common.exceptions.CelOverloadNotFoundException; +import dev.cel.runtime.FunctionBindingImpl.DynamicDispatchOverload; import java.util.List; +import org.jspecify.annotations.Nullable; /** * Representation of a function overload which has been resolved to a specific set of argument types @@ -58,12 +60,21 @@ public abstract class CelResolvedOverload { abstract OptimizedFunctionOverload getOptimizedDefinition(); + abstract @Nullable DynamicDispatchOverload getFallbackOverload(); + public Object invoke(Object[] args) throws CelEvaluationException { // Note: canHandle check is handled separately in DynamicDispatchOverload if (isDynamicDispatch() || CelFunctionOverload.canHandle(args, getParameterTypes(), isStrict())) { return getDefinition().apply(args); } + DynamicDispatchOverload fallback = getFallbackOverload(); + if (fallback != null) { + FunctionBindingImpl match = fallback.findOverload(args); + if (match != null) { + return match.getDefinition().apply(args); + } + } throw new CelOverloadNotFoundException(getFunctionName(), ImmutableList.of(getOverloadId())); } @@ -72,6 +83,13 @@ public Object invoke(Object arg) throws CelEvaluationException { || CelFunctionOverload.canHandle(arg, getParameterTypes(), isStrict())) { return getOptimizedDefinition().apply(arg); } + DynamicDispatchOverload fallback = getFallbackOverload(); + if (fallback != null) { + FunctionBindingImpl match = fallback.findOverload(arg); + if (match != null) { + return match.getOptimizedDefinition().apply(arg); + } + } throw new CelOverloadNotFoundException(getFunctionName(), ImmutableList.of(getOverloadId())); } @@ -80,6 +98,13 @@ public Object invoke(Object arg1, Object arg2) throws CelEvaluationException { || CelFunctionOverload.canHandle(arg1, arg2, getParameterTypes(), isStrict())) { return getOptimizedDefinition().apply(arg1, arg2); } + DynamicDispatchOverload fallback = getFallbackOverload(); + if (fallback != null) { + FunctionBindingImpl match = fallback.findOverload(arg1, arg2); + if (match != null) { + return match.getOptimizedDefinition().apply(arg1, arg2); + } + } throw new CelOverloadNotFoundException(getFunctionName(), ImmutableList.of(getOverloadId())); } @@ -106,13 +131,30 @@ public static CelResolvedOverload of( CelFunctionOverload definition, boolean isStrict, List> parameterTypes) { + return of( + functionName, + overloadId, + definition, + isStrict, + parameterTypes, + /* fallbackOverload= */ null); + } + + static CelResolvedOverload of( + String functionName, + String overloadId, + CelFunctionOverload definition, + boolean isStrict, + List> parameterTypes, + @Nullable DynamicDispatchOverload fallbackOverload) { return new AutoValue_CelResolvedOverload( functionName, overloadId, ImmutableList.copyOf(parameterTypes), isStrict, definition, - OptimizedFunctionOverload.of(definition)); + OptimizedFunctionOverload.of(definition), + fallbackOverload); } /** @@ -123,6 +165,6 @@ boolean canHandle(Object[] arguments) { } private boolean isDynamicDispatch() { - return getDefinition() instanceof FunctionBindingImpl.DynamicDispatchOverload; + return getDefinition() instanceof DynamicDispatchOverload; } } diff --git a/runtime/src/main/java/dev/cel/runtime/DefaultDispatcher.java b/runtime/src/main/java/dev/cel/runtime/DefaultDispatcher.java index 3fcc1d248..709be3c9d 100644 --- a/runtime/src/main/java/dev/cel/runtime/DefaultDispatcher.java +++ b/runtime/src/main/java/dev/cel/runtime/DefaultDispatcher.java @@ -71,12 +71,23 @@ static Optional findOverloadMatchingArgs( throws CelEvaluationException { int matchingOverloadCount = 0; CelResolvedOverload match = null; + DynamicDispatchOverload fallback = null; List candidates = null; for (String overloadId : overloadIds) { CelResolvedOverload overload = overloads.get(overloadId); // If the overload is null, it means that the function was not registered; however, it is // possible that the overload refers to a late-bound function. - if (overload != null && overload.canHandle(args)) { + if (overload == null || overload.getDefinition() instanceof DynamicDispatchOverload) { + continue; + } + DynamicDispatchOverload overloadFallback = overload.getFallbackOverload(); + if (overloadFallback != null) { + if (!overload.getFunctionName().equals(functionName)) { + continue; + } + fallback = overloadFallback; + } + if (overload.canHandle(args)) { if (++matchingOverloadCount > 1) { if (candidates == null) { candidates = new ArrayList<>(); @@ -88,6 +99,15 @@ static Optional findOverloadMatchingArgs( } } + if (matchingOverloadCount == 1) { + return Optional.of(match); + } + if (fallback != null) { + FunctionBindingImpl dynamicMatch = fallback.findOverload(args); + if (dynamicMatch != null) { + return Optional.of(overloads.get(dynamicMatch.getOverloadId())); + } + } if (matchingOverloadCount > 1) { throw CelEvaluationExceptionBuilder.newBuilder( "Ambiguous overloads for function '%s'. Matching candidates: %s", @@ -95,7 +115,7 @@ static Optional findOverloadMatchingArgs( .setErrorCode(CelErrorCode.AMBIGUOUS_OVERLOAD) .build(); } - return Optional.ofNullable(match); + return Optional.empty(); } /** @@ -208,16 +228,21 @@ public DefaultDispatcher build() { for (Map.Entry entry : overloads.entrySet()) { String overloadId = entry.getKey(); OverloadEntry overloadEntry = entry.getValue(); - CelFunctionOverload overloadImpl = overloadEntry.overload(); + OverloadEntry functionEntry = overloads.get(overloadEntry.functionName()); + DynamicDispatchOverload fallback = + functionEntry != null && functionEntry.overload() instanceof DynamicDispatchOverload + ? (DynamicDispatchOverload) functionEntry.overload() + : null; resolvedOverloads.put( overloadId, CelResolvedOverload.of( overloadEntry.functionName(), overloadId, - overloadImpl, + overloadEntry.overload(), overloadEntry.isStrict(), - overloadEntry.argTypes())); + overloadEntry.argTypes(), + fallback)); } return new DefaultDispatcher(resolvedOverloads.buildOrThrow()); diff --git a/runtime/src/main/java/dev/cel/runtime/FunctionBindingImpl.java b/runtime/src/main/java/dev/cel/runtime/FunctionBindingImpl.java index c07ba8744..37ae18a62 100644 --- a/runtime/src/main/java/dev/cel/runtime/FunctionBindingImpl.java +++ b/runtime/src/main/java/dev/cel/runtime/FunctionBindingImpl.java @@ -22,6 +22,7 @@ import dev.cel.common.exceptions.CelOverloadNotFoundException; import java.util.LinkedHashMap; import java.util.Map; +import org.jspecify.annotations.Nullable; @Immutable final class FunctionBindingImpl implements InternalCelFunctionBinding { @@ -174,42 +175,61 @@ static final class DynamicDispatchOverload implements OptimizedFunctionOverload @Override public Object apply(Object[] args) throws CelEvaluationException { + FunctionBindingImpl overload = findOverload(args); + if (overload != null) { + return overload.getDefinition().apply(args); + } + throw newOverloadNotFoundException(); + } + + @Override + public Object apply(Object arg) throws CelEvaluationException { + FunctionBindingImpl overload = findOverload(arg); + if (overload != null) { + return overload.getOptimizedDefinition().apply(arg); + } + throw newOverloadNotFoundException(); + } + + @Override + public Object apply(Object arg1, Object arg2) throws CelEvaluationException { + FunctionBindingImpl overload = findOverload(arg1, arg2); + if (overload != null) { + return overload.getOptimizedDefinition().apply(arg1, arg2); + } + throw newOverloadNotFoundException(); + } + + @Nullable FunctionBindingImpl findOverload(Object[] args) { for (FunctionBindingImpl overload : overloadBindings) { if (CelFunctionOverload.canHandle(args, overload.getArgTypes(), overload.isStrict())) { - return overload.getDefinition().apply(args); + return overload; } } - - throw new CelOverloadNotFoundException( - functionName, - overloadBindings.stream() - .map(CelFunctionBinding::getOverloadId) - .collect(toImmutableList())); + return null; } - @Override - public Object apply(Object arg) throws CelEvaluationException { + @Nullable FunctionBindingImpl findOverload(Object arg) { for (FunctionBindingImpl overload : overloadBindings) { if (CelFunctionOverload.canHandle(arg, overload.getArgTypes(), overload.isStrict())) { - return overload.getOptimizedDefinition().apply(arg); + return overload; } } - throw new CelOverloadNotFoundException( - functionName, - overloadBindings.stream() - .map(CelFunctionBinding::getOverloadId) - .collect(toImmutableList())); + return null; } - @Override - public Object apply(Object arg1, Object arg2) throws CelEvaluationException { + @Nullable FunctionBindingImpl findOverload(Object arg1, Object arg2) { for (FunctionBindingImpl overload : overloadBindings) { if (CelFunctionOverload.canHandle( arg1, arg2, overload.getArgTypes(), overload.isStrict())) { - return overload.getOptimizedDefinition().apply(arg1, arg2); + return overload; } } - throw new CelOverloadNotFoundException( + return null; + } + + private CelOverloadNotFoundException newOverloadNotFoundException() { + return new CelOverloadNotFoundException( functionName, overloadBindings.stream() .map(CelFunctionBinding::getOverloadId) diff --git a/runtime/src/test/java/dev/cel/runtime/CelLateFunctionBindingsTest.java b/runtime/src/test/java/dev/cel/runtime/CelLateFunctionBindingsTest.java index 819b99665..bb30bfcb2 100644 --- a/runtime/src/test/java/dev/cel/runtime/CelLateFunctionBindingsTest.java +++ b/runtime/src/test/java/dev/cel/runtime/CelLateFunctionBindingsTest.java @@ -17,6 +17,7 @@ import static com.google.common.truth.Truth.assertThat; import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableSet; import com.google.common.primitives.UnsignedLong; import dev.cel.common.CelErrorCode; import dev.cel.expr.conformance.proto3.TestAllTypes; @@ -139,4 +140,32 @@ public void findOverload_nullMessageArg_isEmpty() throws Exception { "identity", ImmutableList.of("identity_msg"), new Object[] {null}); assertThat(overload).isEmpty(); } + + @Test + public void findOverload_parsedOnlyFromOverloads_scopesToMatchingFunctionName() throws Exception { + CelLateFunctionBindings bindings = + CelLateFunctionBindings.from( + ImmutableSet.builder() + .addAll( + CelFunctionBinding.fromOverloads( + "fnA", CelFunctionBinding.from("fnA_str", String.class, s -> "A:" + s))) + .addAll( + CelFunctionBinding.fromOverloads( + "fnB", CelFunctionBinding.from("fnB_str", String.class, s -> "B:" + s))) + .addAll( + CelFunctionBinding.fromOverloads( + "fnC", CelFunctionBinding.from("fnC_int", Long.class, x -> x))) + .build()); + + Optional fnBMatch = + bindings.findOverloadMatchingArgs("fnB", new Object[] {"hi"}); + Optional fnCMismatch = + bindings.findOverloadMatchingArgs("fnC", new Object[] {"hi"}); + Optional zeroArgMismatch = + bindings.findOverloadMatchingArgs("fnC", new Object[0]); + + assertThat(fnBMatch.map(CelResolvedOverload::getOverloadId)).hasValue("fnB_str"); + assertThat(fnCMismatch).isEmpty(); + assertThat(zeroArgMismatch).isEmpty(); + } } diff --git a/runtime/src/test/java/dev/cel/runtime/CelResolvedOverloadTest.java b/runtime/src/test/java/dev/cel/runtime/CelResolvedOverloadTest.java index 471282117..484492847 100644 --- a/runtime/src/test/java/dev/cel/runtime/CelResolvedOverloadTest.java +++ b/runtime/src/test/java/dev/cel/runtime/CelResolvedOverloadTest.java @@ -15,7 +15,9 @@ package dev.cel.runtime; import static com.google.common.truth.Truth.assertThat; +import static org.junit.Assert.assertThrows; +import dev.cel.common.exceptions.CelOverloadNotFoundException; import dev.cel.expr.conformance.proto3.TestAllTypes; import org.junit.Test; import org.junit.runner.RunWith; @@ -111,4 +113,65 @@ public void canHandle_nonStrictOverload_returnsFalse() { Long.class); assertThat(nonStrictOverload.canHandle(new Object[] {new RuntimeException(), "Foo"})).isFalse(); } + + @Test + public void invoke_fallbackOverloadMatches_dispatchesAcrossArities() throws Exception { + DefaultDispatcher dispatcher = newFallbackTestDispatcher(); + CelResolvedOverload unary = dispatcher.findOverload("fn_int").get(); + CelResolvedOverload binary = dispatcher.findOverload("fn_bin_int").get(); + + Object primaryUnary = unary.invoke(1L); + Object fallbackUnary = unary.invoke("hi"); + Object fallbackVarargs = unary.invoke(new Object[] {"hi"}); + Object fallbackBinary = binary.invoke("a", "b"); + + assertThat(primaryUnary).isEqualTo(2L); + assertThat(fallbackUnary).isEqualTo("hi!"); + assertThat(fallbackVarargs).isEqualTo("hi!"); + assertThat(fallbackBinary).isEqualTo("ab"); + } + + @Test + public void invoke_noFallbackMatch_preservesPrimaryCandidateInException() { + DefaultDispatcher dispatcher = newFallbackTestDispatcher(); + CelResolvedOverload unary = dispatcher.findOverload("fn_int").get(); + CelResolvedOverload binary = dispatcher.findOverload("fn_bin_int").get(); + CelResolvedOverload noFallback = getIncrementIntOverload(); + Object[] badArgs = new Object[] {"bad"}; + + CelOverloadNotFoundException unaryErr = + assertThrows(CelOverloadNotFoundException.class, () -> unary.invoke(true)); + CelOverloadNotFoundException varargsErr = + assertThrows(CelOverloadNotFoundException.class, () -> unary.invoke(new Object[] {true})); + CelOverloadNotFoundException binaryErr = + assertThrows(CelOverloadNotFoundException.class, () -> binary.invoke(true, false)); + CelOverloadNotFoundException noFallbackVarargsErr = + assertThrows(CelOverloadNotFoundException.class, () -> noFallback.invoke(badArgs)); + + assertThat(unaryErr).hasMessageThat().contains("Overload candidates: fn_int"); + assertThat(varargsErr).hasMessageThat().contains("Overload candidates: fn_int"); + assertThat(binaryErr).hasMessageThat().contains("Overload candidates: fn_bin_int"); + assertThat(noFallbackVarargsErr) + .hasMessageThat() + .contains("Overload candidates: increment_int_overload"); + } + + private static DefaultDispatcher newFallbackTestDispatcher() { + DefaultDispatcher.Builder builder = DefaultDispatcher.newBuilder(); + for (CelFunctionBinding binding : + CelFunctionBinding.fromOverloads( + "fn", + CelFunctionBinding.from("fn_int", Long.class, x -> x + 1L), + CelFunctionBinding.from("fn_str", String.class, s -> s + "!"), + CelFunctionBinding.from("fn_bin_int", Long.class, Long.class, Long::sum), + CelFunctionBinding.from("fn_bin_str", String.class, String.class, String::concat))) { + builder.addOverload( + ((InternalCelFunctionBinding) binding).getFunctionName(), + binding.getOverloadId(), + binding.getArgTypes(), + binding.isStrict(), + binding.getDefinition()); + } + return builder.build(); + } } diff --git a/runtime/src/test/java/dev/cel/runtime/CelRuntimeLegacyImplTest.java b/runtime/src/test/java/dev/cel/runtime/CelRuntimeLegacyImplTest.java index 7efb8d929..f4fd3f637 100644 --- a/runtime/src/test/java/dev/cel/runtime/CelRuntimeLegacyImplTest.java +++ b/runtime/src/test/java/dev/cel/runtime/CelRuntimeLegacyImplTest.java @@ -16,6 +16,8 @@ import static com.google.common.truth.Truth.assertThat; import static com.google.common.util.concurrent.MoreExecutors.newDirectExecutorService; +import static dev.cel.common.CelFunctionDecl.newFunctionDeclaration; +import static dev.cel.common.CelOverloadDecl.newGlobalOverload; import static org.junit.Assert.assertThrows; import com.google.common.collect.ImmutableMap; @@ -26,8 +28,10 @@ import com.google.protobuf.DynamicMessage; import com.google.protobuf.Message; import dev.cel.common.CelAbstractSyntaxTree; +import dev.cel.common.CelErrorCode; import dev.cel.common.CelException; import dev.cel.common.exceptions.CelDivideByZeroException; +import dev.cel.common.types.SimpleType; import dev.cel.compiler.CelCompiler; import dev.cel.compiler.CelCompilerFactory; import dev.cel.expr.conformance.proto3.TestAllTypes; @@ -39,6 +43,7 @@ import org.junit.runners.JUnit4; @RunWith(JUnit4.class) +@SuppressWarnings("deprecation") // Tests legacy runtime implementation. public final class CelRuntimeLegacyImplTest { @Test @@ -236,4 +241,40 @@ public void evalAsync_legacyInterpreter_throwsUnsupportedOperationException() th () -> program.evalAsync(resolver, CelFunctionResolver.EMPTY)); assertThrows(UnsupportedOperationException.class, () -> program.evalAsync((PartialVars) null)); } + + @Test + public void eval_narrowedDynOverloadFallback_dispatchesByRuntimeValueType() throws Exception { + CelCompiler compiler = CelCompilerFactory.standardCelCompilerBuilder().build(); + CelRuntime runtime = CelRuntimeFactory.legacyCelRuntimeBuilder().build(); + CelRuntime.Program program = + runtime.createProgram(compiler.compile("-([1] + dyn([1.5]))[1]").getAst()); + + Object result = program.eval(); + + assertThat(result).isEqualTo(-1.5d); + } + + @Test + public void eval_standaloneBindingsWithDuplicateRuntimeArgTypes_throwsAmbiguousOverload() + throws Exception { + CelCompiler compiler = + CelCompilerFactory.standardCelCompilerBuilder() + .addFunctionDeclarations( + newFunctionDeclaration( + "dup", + newGlobalOverload("dup_int", SimpleType.INT, SimpleType.INT), + newGlobalOverload("dup_str", SimpleType.INT, SimpleType.STRING))) + .build(); + CelRuntime runtime = + CelRuntimeFactory.legacyCelRuntimeBuilder() + .addFunctionBindings( + CelFunctionBinding.from("dup_int", Long.class, x -> x), + CelFunctionBinding.from("dup_str", Long.class, x -> x)) + .build(); + CelRuntime.Program program = runtime.createProgram(compiler.compile("dup(dyn(1))").getAst()); + + CelEvaluationException e = assertThrows(CelEvaluationException.class, program::eval); + + assertThat(e.getErrorCode()).isEqualTo(CelErrorCode.AMBIGUOUS_OVERLOAD); + } } diff --git a/runtime/src/test/java/dev/cel/runtime/planner/ProgramPlannerTest.java b/runtime/src/test/java/dev/cel/runtime/planner/ProgramPlannerTest.java index 2c3e2ee66..97d18a716 100644 --- a/runtime/src/test/java/dev/cel/runtime/planner/ProgramPlannerTest.java +++ b/runtime/src/test/java/dev/cel/runtime/planner/ProgramPlannerTest.java @@ -22,6 +22,7 @@ import static dev.cel.common.CelOverloadDecl.newMemberOverload; import static java.nio.charset.StandardCharsets.UTF_8; import static org.junit.Assert.assertThrows; +import static org.junit.Assume.assumeFalse; import com.google.common.collect.ImmutableCollection; import com.google.common.collect.ImmutableList; @@ -94,6 +95,7 @@ import dev.cel.runtime.RuntimeHelpers; import dev.cel.runtime.standard.TypeFunction; import java.util.HashMap; +import java.util.List; import java.util.Map; import java.util.Optional; import org.junit.Test; @@ -186,7 +188,8 @@ public final class ProgramPlannerTest { newFunctionDeclaration( "late_bound_func", newGlobalOverload( - "late_bound_func_overload", SimpleType.STRING, SimpleType.STRING))) + "late_bound_func_overload", SimpleType.STRING, SimpleType.STRING), + newGlobalOverload("late_bound_func_int", SimpleType.STRING, SimpleType.INT))) .addVar("msg", StructTypeReference.create(TestAllTypes.getDescriptor().getFullName())) .addVar("map_var", MapType.create(SimpleType.STRING, SimpleType.DYN)) .addVar("int_var", SimpleType.INT) @@ -199,6 +202,22 @@ public final class ProgramPlannerTest { "neg", newGlobalOverload("neg_int", SimpleType.INT, SimpleType.INT), newGlobalOverload("neg_double", SimpleType.DOUBLE, SimpleType.DOUBLE)), + newFunctionDeclaration( + "func", + newGlobalOverload( + "func_int", SimpleType.INT, SimpleType.INT, SimpleType.INT, SimpleType.INT), + newGlobalOverload( + "func_str", + SimpleType.INT, + SimpleType.STRING, + SimpleType.INT, + SimpleType.INT)), + newFunctionDeclaration( + "describe", + newGlobalOverload( + "describe_ints", SimpleType.STRING, ListType.create(SimpleType.INT)), + newGlobalOverload( + "describe_strs", SimpleType.STRING, ListType.create(SimpleType.STRING))), newFunctionDeclaration( "cel.expr.conformance.proto3.power", newGlobalOverload( @@ -232,6 +251,7 @@ private static DefaultDispatcher newDispatcher(CelOptions celOptions) { .includeFunctions( StandardFunction.INDEX, StandardFunction.LOGICAL_NOT, + StandardFunction.NEGATE, StandardFunction.ADD, StandardFunction.GREATER, StandardFunction.GREATER_EQUALS, @@ -239,6 +259,8 @@ private static DefaultDispatcher newDispatcher(CelOptions celOptions) { StandardFunction.LESS_EQUALS, StandardFunction.DIVIDE, StandardFunction.EQUALS, + StandardFunction.IN, + StandardFunction.INT, StandardFunction.NOT_STRICTLY_FALSE, StandardFunction.SIZE, StandardFunction.MATCHES, @@ -296,7 +318,18 @@ private static DefaultDispatcher newDispatcher(CelOptions celOptions) { CelFunctionBinding.from( "func_int", ImmutableList.of(Long.class, Long.class, Long.class), - (args) -> (long) args.length))); + args -> (long) args.length), + CelFunctionBinding.from( + "func_str", + ImmutableList.of(String.class, Long.class, Long.class), + args -> (long) ((String) args[0]).length()))); + + addBindingsToDispatcher( + builder, + CelFunctionBinding.fromOverloads( + "describe", + CelFunctionBinding.from("describe_ints", List.class, unused -> "ints"), + CelFunctionBinding.from("describe_strs", List.class, unused -> "strs"))); addBindingsToDispatcher( builder, @@ -2894,6 +2927,72 @@ public void plan_call_greaterEquals_heterogeneousNumeric( assertThat(result).isEqualTo(expectedResult); } + @Test + public void plan_call_narrowedDynOverloadFallback_dispatchesByRuntimeValueType( + @TestParameter({ + "-([1] + dyn([1.5]))[1] == dyn(-1.5)", + "1 in ([{1: 2}] + dyn([[1]]))[1]", + "size((['a'] + dyn([[1, 2, 3]]))[1]) == 3", + "((['a'] + dyn([[1, 2, 3]]))[1]).size() == 3", + "int((['1'] + dyn([2.9]))[1]) == 2", + "func(([1] + dyn(['abcd']))[1], 2, 3) == 4", + "type(false ? TestAllTypes{} : (true ? dyn(1) : null)) == int", + }) + String expression) + throws Exception { + Program program = PLANNER.plan(compile(expression)); + + Object result = program.eval(); + + assertThat(result).isEqualTo(true); + } + + @Test + @TestParameters("{expression: 'neg(([1] + dyn([true]))[1])', fn: 'neg', checked: 'neg_int'}") + @TestParameters( + "{expression: 'func(([1] + dyn([true]))[1], 2, 3)', fn: 'func', checked: 'func_int'}") + public void plan_call_narrowedDynOverloadFallback_noMatchingOverload_preservesCheckedCandidate( + String expression, String fn, String checked) throws Exception { + assumeFalse(isParseOnly); + Program program = PLANNER.plan(compile(expression)); + + CelEvaluationException e = assertThrows(CelEvaluationException.class, program::eval); + + assertThat(e) + .hasMessageThat() + .contains( + String.format( + "No matching overload for function '%s'. Overload candidates: %s", fn, checked)); + } + + @Test + @TestParameters("{expression: 'describe([])', expected: 'ints'}") + @TestParameters("{expression: \"describe(['a'])\", expected: 'strs'}") + public void plan_call_checkedErasedGenericOverload_preservesStaticSelection( + String expression, String expected) throws Exception { + assumeFalse(isParseOnly); + Program program = PLANNER.plan(compile(expression)); + + Object result = program.eval(); + + assertThat(result).isEqualTo(expected); + } + + @Test + public void plan_call_lateBoundFunction_narrowedDynOverloadFallback() throws Exception { + Program program = PLANNER.plan(compile("late_bound_func((['a'] + dyn([42]))[1])")); + CelLateFunctionBindings lateBindings = + CelLateFunctionBindings.from( + CelFunctionBinding.fromOverloads( + "late_bound_func", + CelFunctionBinding.from("late_bound_func_overload", String.class, s -> "str:" + s), + CelFunctionBinding.from("late_bound_func_int", Long.class, n -> "int:" + n))); + + Object result = program.eval(ImmutableMap.of(), lateBindings); + + assertThat(result).isEqualTo("int:42"); + } + private static ProgramPlanner newPlannerWithOptions(CelOptions options) { return ProgramPlanner.newPlanner( TYPE_PROVIDER,